#![allow(unused_qualifications)]

#[cfg(any(feature = "client", feature = "server"))]
use crate::header;
use crate::models;

// Methods for converting between header::IntoHeaderValue<AuthOidc> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidc>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<AuthOidc>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for AuthOidc - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidc> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <AuthOidc as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into AuthOidc - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct AuthOidc {
    /// Fatcat-specific short name (slug) for remote service being used for authentication.
    #[serde(rename = "provider")]
    pub provider: String,

    /// `SUB` from OIDC protocol. Usually a URL.
    #[serde(rename = "sub")]
    pub sub: String,

    /// `ISS` from OIDC protocol. Usually a stable account username, number, or identifier.
    #[serde(rename = "iss")]
    pub iss: String,

    /// What it sounds like; returned by OIDC, and used as a hint when creating new editor accounts. Fatcat usernames are usually this string with the `provider` slug as a suffix, though some munging may occur.
    #[serde(rename = "preferred_username")]
    pub preferred_username: String,
}

impl AuthOidc {
    pub fn new(provider: String, sub: String, iss: String, preferred_username: String) -> AuthOidc {
        AuthOidc {
            provider: provider,
            sub: sub,
            iss: iss,
            preferred_username: preferred_username,
        }
    }
}

/// Converts the AuthOidc value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for AuthOidc {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("provider".to_string());
        params.push(self.provider.to_string());

        params.push("sub".to_string());
        params.push(self.sub.to_string());

        params.push("iss".to_string());
        params.push(self.iss.to_string());

        params.push("preferred_username".to_string());
        params.push(self.preferred_username.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidc value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for AuthOidc {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub provider: Vec<String>,
            pub sub: Vec<String>,
            pub iss: Vec<String>,
            pub preferred_username: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing AuthOidc".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "provider" => intermediate_rep
                        .provider
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "sub" => intermediate_rep
                        .sub
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "iss" => intermediate_rep
                        .iss
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "preferred_username" => intermediate_rep
                        .preferred_username
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing AuthOidc".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(AuthOidc {
            provider: intermediate_rep
                .provider
                .into_iter()
                .next()
                .ok_or("provider missing in AuthOidc".to_string())?,
            sub: intermediate_rep
                .sub
                .into_iter()
                .next()
                .ok_or("sub missing in AuthOidc".to_string())?,
            iss: intermediate_rep
                .iss
                .into_iter()
                .next()
                .ok_or("iss missing in AuthOidc".to_string())?,
            preferred_username: intermediate_rep
                .preferred_username
                .into_iter()
                .next()
                .ok_or("preferred_username missing in AuthOidc".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<AuthOidcResult> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidcResult>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<AuthOidcResult>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for AuthOidcResult - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidcResult> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <AuthOidcResult as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into AuthOidcResult - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct AuthOidcResult {
    #[serde(rename = "editor")]
    pub editor: models::Editor,

    #[serde(rename = "token")]
    pub token: String,
}

impl AuthOidcResult {
    pub fn new(editor: models::Editor, token: String) -> AuthOidcResult {
        AuthOidcResult {
            editor: editor,
            token: token,
        }
    }
}

/// Converts the AuthOidcResult value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for AuthOidcResult {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editor in query parameter serialization

        params.push("token".to_string());
        params.push(self.token.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidcResult value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for AuthOidcResult {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editor: Vec<models::Editor>,
            pub token: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing AuthOidcResult".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editor" => intermediate_rep
                        .editor
                        .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
                    "token" => intermediate_rep
                        .token
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing AuthOidcResult".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(AuthOidcResult {
            editor: intermediate_rep
                .editor
                .into_iter()
                .next()
                .ok_or("editor missing in AuthOidcResult".to_string())?,
            token: intermediate_rep
                .token
                .into_iter()
                .next()
                .ok_or("token missing in AuthOidcResult".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<AuthTokenResult> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<AuthTokenResult>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<AuthTokenResult>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for AuthTokenResult - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<AuthTokenResult>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <AuthTokenResult as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into AuthTokenResult - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct AuthTokenResult {
    #[serde(rename = "token")]
    pub token: String,
}

impl AuthTokenResult {
    pub fn new(token: String) -> AuthTokenResult {
        AuthTokenResult { token: token }
    }
}

/// Converts the AuthTokenResult value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for AuthTokenResult {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("token".to_string());
        params.push(self.token.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a AuthTokenResult value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for AuthTokenResult {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub token: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing AuthTokenResult".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "token" => intermediate_rep
                        .token
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing AuthTokenResult".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(AuthTokenResult {
            token: intermediate_rep
                .token
                .into_iter()
                .next()
                .ok_or("token missing in AuthTokenResult".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ChangelogEntry> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ChangelogEntry>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ChangelogEntry>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ChangelogEntry - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ChangelogEntry> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ChangelogEntry as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ChangelogEntry - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ChangelogEntry {
    /// Monotonically increasing sequence number of this changelog entry.
    #[serde(rename = "index")]
    pub index: i64,

    /// Identifier of editgroup accepted/merged in this changelog entry.
    #[serde(rename = "editgroup_id")]
    pub editgroup_id: String,

    /// Date and time when the editgroup was accpeted.
    #[serde(rename = "timestamp")]
    pub timestamp: chrono::DateTime<chrono::Utc>,

    #[serde(rename = "editgroup")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editgroup: Option<models::Editgroup>,
}

impl ChangelogEntry {
    pub fn new(
        index: i64,
        editgroup_id: String,
        timestamp: chrono::DateTime<chrono::Utc>,
    ) -> ChangelogEntry {
        ChangelogEntry {
            index: index,
            editgroup_id: editgroup_id,
            timestamp: timestamp,
            editgroup: None,
        }
    }
}

/// Converts the ChangelogEntry value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ChangelogEntry {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("index".to_string());
        params.push(self.index.to_string());

        params.push("editgroup_id".to_string());
        params.push(self.editgroup_id.to_string());

        // Skipping timestamp in query parameter serialization

        // Skipping editgroup in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ChangelogEntry value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ChangelogEntry {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub index: Vec<i64>,
            pub editgroup_id: Vec<String>,
            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
            pub editgroup: Vec<models::Editgroup>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ChangelogEntry".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "index" => intermediate_rep
                        .index
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "editgroup_id" => intermediate_rep
                        .editgroup_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "timestamp" => intermediate_rep.timestamp.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ChangelogEntry".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ChangelogEntry {
            index: intermediate_rep
                .index
                .into_iter()
                .next()
                .ok_or("index missing in ChangelogEntry".to_string())?,
            editgroup_id: intermediate_rep
                .editgroup_id
                .into_iter()
                .next()
                .ok_or("editgroup_id missing in ChangelogEntry".to_string())?,
            timestamp: intermediate_rep
                .timestamp
                .into_iter()
                .next()
                .ok_or("timestamp missing in ChangelogEntry".to_string())?,
            editgroup: intermediate_rep.editgroup.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ContainerAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ContainerAutoBatch>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ContainerAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ContainerAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<ContainerAutoBatch>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ContainerAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ContainerAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ContainerAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::ContainerEntity>,
}

impl ContainerAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::ContainerEntity>,
    ) -> ContainerAutoBatch {
        ContainerAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the ContainerAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ContainerAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ContainerAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ContainerAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::ContainerEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ContainerAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in ContainerAutoBatch"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ContainerAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ContainerAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in ContainerAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in ContainerAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ContainerEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ContainerEntity>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ContainerEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ContainerEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<ContainerEntity>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ContainerEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ContainerEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ContainerEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Name of the container (eg, Journal title). Required for entity creation.
    #[serde(rename = "name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    /// Type of container, eg 'journal' or 'proceedings'. See Guide for list of valid types.
    #[serde(rename = "container_type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_type: Option<String>,

    /// Name of the organization or entity responsible for publication. Not the complete imprint/brand.
    #[serde(rename = "publisher")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<String>,

    /// Linking ISSN number (ISSN-L). Should be valid and registered with issn.org
    #[serde(rename = "issnl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issnl: Option<String>,

    #[serde(rename = "wikidata_qid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wikidata_qid: Option<String>,
}

impl ContainerEntity {
    pub fn new() -> ContainerEntity {
        ContainerEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
            name: None,
            container_type: None,
            publisher: None,
            issnl: None,
            wikidata_qid: None,
        }
    }
}

/// Converts the ContainerEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ContainerEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        if let Some(ref name) = self.name {
            params.push("name".to_string());
            params.push(name.to_string());
        }

        if let Some(ref container_type) = self.container_type {
            params.push("container_type".to_string());
            params.push(container_type.to_string());
        }

        if let Some(ref publisher) = self.publisher {
            params.push("publisher".to_string());
            params.push(publisher.to_string());
        }

        if let Some(ref issnl) = self.issnl {
            params.push("issnl".to_string());
            params.push(issnl.to_string());
        }

        if let Some(ref wikidata_qid) = self.wikidata_qid {
            params.push("wikidata_qid".to_string());
            params.push(wikidata_qid.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ContainerEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ContainerEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub name: Vec<String>,
            pub container_type: Vec<String>,
            pub publisher: Vec<String>,
            pub issnl: Vec<String>,
            pub wikidata_qid: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ContainerEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ContainerEntity"
                                .to_string(),
                        )
                    }
                    "edit_extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ContainerEntity"
                                .to_string(),
                        )
                    }
                    "name" => intermediate_rep
                        .name
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "container_type" => intermediate_rep
                        .container_type
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "publisher" => intermediate_rep
                        .publisher
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "issnl" => intermediate_rep
                        .issnl
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "wikidata_qid" => intermediate_rep
                        .wikidata_qid
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ContainerEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ContainerEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
            name: intermediate_rep.name.into_iter().next(),
            container_type: intermediate_rep.container_type.into_iter().next(),
            publisher: intermediate_rep.publisher.into_iter().next(),
            issnl: intermediate_rep.issnl.into_iter().next(),
            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<CreatorAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<CreatorAutoBatch>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<CreatorAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for CreatorAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<CreatorAutoBatch>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <CreatorAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into CreatorAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct CreatorAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::CreatorEntity>,
}

impl CreatorAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::CreatorEntity>,
    ) -> CreatorAutoBatch {
        CreatorAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the CreatorAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for CreatorAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a CreatorAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for CreatorAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::CreatorEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing CreatorAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in CreatorAutoBatch"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing CreatorAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(CreatorAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in CreatorAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in CreatorAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<CreatorEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<CreatorEntity>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<CreatorEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for CreatorEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<CreatorEntity> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <CreatorEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into CreatorEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct CreatorEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Name as should be displayed in web interface or in author lists (not index/sorted). Required for valid entities.
    #[serde(rename = "display_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,

    /// In English commonly the first name, but ordering is context and culture specific.
    #[serde(rename = "given_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<String>,

    /// In English commonly the last, or family name, but ordering is context and culture specific.
    #[serde(rename = "surname")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub surname: Option<String>,

    /// ORCiD (https://orcid.org) identifier
    #[serde(rename = "orcid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orcid: Option<String>,

    /// Wikidata entity QID
    #[serde(rename = "wikidata_qid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wikidata_qid: Option<String>,
}

impl CreatorEntity {
    pub fn new() -> CreatorEntity {
        CreatorEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
            display_name: None,
            given_name: None,
            surname: None,
            orcid: None,
            wikidata_qid: None,
        }
    }
}

/// Converts the CreatorEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for CreatorEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        if let Some(ref display_name) = self.display_name {
            params.push("display_name".to_string());
            params.push(display_name.to_string());
        }

        if let Some(ref given_name) = self.given_name {
            params.push("given_name".to_string());
            params.push(given_name.to_string());
        }

        if let Some(ref surname) = self.surname {
            params.push("surname".to_string());
            params.push(surname.to_string());
        }

        if let Some(ref orcid) = self.orcid {
            params.push("orcid".to_string());
            params.push(orcid.to_string());
        }

        if let Some(ref wikidata_qid) = self.wikidata_qid {
            params.push("wikidata_qid".to_string());
            params.push(wikidata_qid.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a CreatorEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for CreatorEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub display_name: Vec<String>,
            pub given_name: Vec<String>,
            pub surname: Vec<String>,
            pub orcid: Vec<String>,
            pub wikidata_qid: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing CreatorEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in CreatorEntity"
                                .to_string(),
                        )
                    }
                    "edit_extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in CreatorEntity"
                                .to_string(),
                        )
                    }
                    "display_name" => intermediate_rep
                        .display_name
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "given_name" => intermediate_rep
                        .given_name
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "surname" => intermediate_rep
                        .surname
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "orcid" => intermediate_rep
                        .orcid
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "wikidata_qid" => intermediate_rep
                        .wikidata_qid
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing CreatorEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(CreatorEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
            display_name: intermediate_rep.display_name.into_iter().next(),
            given_name: intermediate_rep.given_name.into_iter().next(),
            surname: intermediate_rep.surname.into_iter().next(),
            orcid: intermediate_rep.orcid.into_iter().next(),
            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<Editgroup> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<Editgroup>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<Editgroup>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for Editgroup - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editgroup> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <Editgroup as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into Editgroup - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Editgroup {
    /// Fatcat identifier for this editgroup. Assigned on creation.
    #[serde(rename = "editgroup_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editgroup_id: Option<String>,

    /// Fatcat identifer of editor that created this editgroup.
    #[serde(rename = "editor_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor_id: Option<String>,

    #[serde(rename = "editor")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<models::Editor>,

    /// For accepted/merged editgroups, the changelog index that the accept occured at. WARNING: not populated in all contexts that an editgroup could be included in a response.
    #[serde(rename = "changelog_index")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub changelog_index: Option<i64>,

    /// Timestamp when this editgroup was first created.
    #[serde(rename = "created")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created: Option<chrono::DateTime<chrono::Utc>>,

    /// Timestamp when this editgroup was most recently submitted for review. If withdrawn, or never submitted, will be `null`.
    #[serde(rename = "submitted")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub submitted: Option<chrono::DateTime<chrono::Utc>>,

    /// Comment describing the changes in this editgroup. Can be updated with PUT request.
    #[serde(rename = "description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Free-form JSON metadata attached to this editgroup. Eg, metadata provenance, or script user-agent details. See guide for (unenforced) schema norms.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
    #[serde(rename = "annotations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Vec<models::EditgroupAnnotation>>,

    #[serde(rename = "edits")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edits: Option<models::EditgroupEdits>,
}

impl Editgroup {
    pub fn new() -> Editgroup {
        Editgroup {
            editgroup_id: None,
            editor_id: None,
            editor: None,
            changelog_index: None,
            created: None,
            submitted: None,
            description: None,
            extra: None,
            annotations: None,
            edits: None,
        }
    }
}

/// Converts the Editgroup value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for Editgroup {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref editgroup_id) = self.editgroup_id {
            params.push("editgroup_id".to_string());
            params.push(editgroup_id.to_string());
        }

        if let Some(ref editor_id) = self.editor_id {
            params.push("editor_id".to_string());
            params.push(editor_id.to_string());
        }

        // Skipping editor in query parameter serialization

        if let Some(ref changelog_index) = self.changelog_index {
            params.push("changelog_index".to_string());
            params.push(changelog_index.to_string());
        }

        // Skipping created in query parameter serialization

        // Skipping submitted in query parameter serialization

        if let Some(ref description) = self.description {
            params.push("description".to_string());
            params.push(description.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping annotations in query parameter serialization

        // Skipping edits in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a Editgroup value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for Editgroup {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup_id: Vec<String>,
            pub editor_id: Vec<String>,
            pub editor: Vec<models::Editor>,
            pub changelog_index: Vec<i64>,
            pub created: Vec<chrono::DateTime<chrono::Utc>>,
            pub submitted: Vec<chrono::DateTime<chrono::Utc>>,
            pub description: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub annotations: Vec<Vec<models::EditgroupAnnotation>>,
            pub edits: Vec<models::EditgroupEdits>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing Editgroup".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup_id" => intermediate_rep
                        .editgroup_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "editor_id" => intermediate_rep
                        .editor_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "editor" => intermediate_rep
                        .editor
                        .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
                    "changelog_index" => intermediate_rep
                        .changelog_index
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "created" => intermediate_rep.created.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "submitted" => intermediate_rep.submitted.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "description" => intermediate_rep
                        .description
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in Editgroup"
                                .to_string(),
                        )
                    }
                    "annotations" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in Editgroup"
                                .to_string(),
                        )
                    }
                    "edits" => intermediate_rep
                        .edits
                        .push(models::EditgroupEdits::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Editgroup".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Editgroup {
            editgroup_id: intermediate_rep.editgroup_id.into_iter().next(),
            editor_id: intermediate_rep.editor_id.into_iter().next(),
            editor: intermediate_rep.editor.into_iter().next(),
            changelog_index: intermediate_rep.changelog_index.into_iter().next(),
            created: intermediate_rep.created.into_iter().next(),
            submitted: intermediate_rep.submitted.into_iter().next(),
            description: intermediate_rep.description.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            annotations: intermediate_rep.annotations.into_iter().next(),
            edits: intermediate_rep.edits.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<EditgroupAnnotation> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupAnnotation>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<EditgroupAnnotation>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for EditgroupAnnotation - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<EditgroupAnnotation>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <EditgroupAnnotation as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into EditgroupAnnotation - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct EditgroupAnnotation {
    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "annotation_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<String>,

    /// Editgroup that this annotation applies to. Set automatically in creations based on URL parameter.
    #[serde(rename = "editgroup_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editgroup_id: Option<String>,

    /// Defaults to editor created the annotation via POST request.
    #[serde(rename = "editor_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor_id: Option<String>,

    #[serde(rename = "editor")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<models::Editor>,

    /// Timestamp when annotation was first created.
    #[serde(rename = "created")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created: Option<chrono::DateTime<chrono::Utc>>,

    #[serde(rename = "comment_markdown")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment_markdown: Option<String>,

    /// Additional free-form JSON metadata that can be included as part of the annotation (or even as the primary annotation itself). See guide for details.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl EditgroupAnnotation {
    pub fn new() -> EditgroupAnnotation {
        EditgroupAnnotation {
            annotation_id: None,
            editgroup_id: None,
            editor_id: None,
            editor: None,
            created: None,
            comment_markdown: None,
            extra: None,
        }
    }
}

/// Converts the EditgroupAnnotation value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for EditgroupAnnotation {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref annotation_id) = self.annotation_id {
            params.push("annotation_id".to_string());
            params.push(annotation_id.to_string());
        }

        if let Some(ref editgroup_id) = self.editgroup_id {
            params.push("editgroup_id".to_string());
            params.push(editgroup_id.to_string());
        }

        if let Some(ref editor_id) = self.editor_id {
            params.push("editor_id".to_string());
            params.push(editor_id.to_string());
        }

        // Skipping editor in query parameter serialization

        // Skipping created in query parameter serialization

        if let Some(ref comment_markdown) = self.comment_markdown {
            params.push("comment_markdown".to_string());
            params.push(comment_markdown.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupAnnotation value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for EditgroupAnnotation {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub annotation_id: Vec<String>,
            pub editgroup_id: Vec<String>,
            pub editor_id: Vec<String>,
            pub editor: Vec<models::Editor>,
            pub created: Vec<chrono::DateTime<chrono::Utc>>,
            pub comment_markdown: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing EditgroupAnnotation".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "annotation_id" => intermediate_rep
                        .annotation_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "editgroup_id" => intermediate_rep
                        .editgroup_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "editor_id" => intermediate_rep
                        .editor_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "editor" => intermediate_rep
                        .editor
                        .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
                    "created" => intermediate_rep.created.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "comment_markdown" => intermediate_rep
                        .comment_markdown
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in EditgroupAnnotation"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing EditgroupAnnotation".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(EditgroupAnnotation {
            annotation_id: intermediate_rep.annotation_id.into_iter().next(),
            editgroup_id: intermediate_rep.editgroup_id.into_iter().next(),
            editor_id: intermediate_rep.editor_id.into_iter().next(),
            editor: intermediate_rep.editor.into_iter().next(),
            created: intermediate_rep.created.into_iter().next(),
            comment_markdown: intermediate_rep.comment_markdown.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
        })
    }
}

/// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
// Methods for converting between header::IntoHeaderValue<EditgroupEdits> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupEdits>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<EditgroupEdits>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for EditgroupEdits - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EditgroupEdits> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <EditgroupEdits as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into EditgroupEdits - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct EditgroupEdits {
    #[serde(rename = "containers")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "creators")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creators: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "files")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "filesets")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filesets: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "webcaptures")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webcaptures: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "works")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub works: Option<Vec<models::EntityEdit>>,
}

impl EditgroupEdits {
    pub fn new() -> EditgroupEdits {
        EditgroupEdits {
            containers: None,
            creators: None,
            files: None,
            filesets: None,
            webcaptures: None,
            releases: None,
            works: None,
        }
    }
}

/// Converts the EditgroupEdits value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for EditgroupEdits {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping containers in query parameter serialization

        // Skipping creators in query parameter serialization

        // Skipping files in query parameter serialization

        // Skipping filesets in query parameter serialization

        // Skipping webcaptures in query parameter serialization

        // Skipping releases in query parameter serialization

        // Skipping works in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupEdits value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for EditgroupEdits {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub containers: Vec<Vec<models::EntityEdit>>,
            pub creators: Vec<Vec<models::EntityEdit>>,
            pub files: Vec<Vec<models::EntityEdit>>,
            pub filesets: Vec<Vec<models::EntityEdit>>,
            pub webcaptures: Vec<Vec<models::EntityEdit>>,
            pub releases: Vec<Vec<models::EntityEdit>>,
            pub works: Vec<Vec<models::EntityEdit>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing EditgroupEdits".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "containers" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    "creators" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    "files" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    "filesets" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    "webcaptures" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    "releases" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    "works" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EditgroupEdits"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing EditgroupEdits".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(EditgroupEdits {
            containers: intermediate_rep.containers.into_iter().next(),
            creators: intermediate_rep.creators.into_iter().next(),
            files: intermediate_rep.files.into_iter().next(),
            filesets: intermediate_rep.filesets.into_iter().next(),
            webcaptures: intermediate_rep.webcaptures.into_iter().next(),
            releases: intermediate_rep.releases.into_iter().next(),
            works: intermediate_rep.works.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<Editor> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<Editor>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<Editor>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for Editor - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editor> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <Editor as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into Editor - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Editor {
    /// Fatcat identifier for the editor. Can not be changed.
    #[serde(rename = "editor_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor_id: Option<String>,

    /// Username/handle (short slug-like string) to identify this editor. May be changed at any time by the editor; use the `editor_id` as a persistend identifer.
    #[serde(rename = "username")]
    pub username: String,

    /// Whether this editor has the `admin` role.
    #[serde(rename = "is_admin")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_admin: Option<bool>,

    /// Whether this editor is a bot (as opposed to a human making manual edits)
    #[serde(rename = "is_bot")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_bot: Option<bool>,

    /// Whether this editor's account is enabled (if not API tokens and web logins will not work).
    #[serde(rename = "is_active")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_active: Option<bool>,
}

impl Editor {
    pub fn new(username: String) -> Editor {
        Editor {
            editor_id: None,
            username: username,
            is_admin: None,
            is_bot: None,
            is_active: None,
        }
    }
}

/// Converts the Editor value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for Editor {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref editor_id) = self.editor_id {
            params.push("editor_id".to_string());
            params.push(editor_id.to_string());
        }

        params.push("username".to_string());
        params.push(self.username.to_string());

        if let Some(ref is_admin) = self.is_admin {
            params.push("is_admin".to_string());
            params.push(is_admin.to_string());
        }

        if let Some(ref is_bot) = self.is_bot {
            params.push("is_bot".to_string());
            params.push(is_bot.to_string());
        }

        if let Some(ref is_active) = self.is_active {
            params.push("is_active".to_string());
            params.push(is_active.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a Editor value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for Editor {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editor_id: Vec<String>,
            pub username: Vec<String>,
            pub is_admin: Vec<bool>,
            pub is_bot: Vec<bool>,
            pub is_active: Vec<bool>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing Editor".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editor_id" => intermediate_rep
                        .editor_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "username" => intermediate_rep
                        .username
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "is_admin" => intermediate_rep
                        .is_admin
                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
                    "is_bot" => intermediate_rep
                        .is_bot
                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
                    "is_active" => intermediate_rep
                        .is_active
                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Editor".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Editor {
            editor_id: intermediate_rep.editor_id.into_iter().next(),
            username: intermediate_rep
                .username
                .into_iter()
                .next()
                .ok_or("username missing in Editor".to_string())?,
            is_admin: intermediate_rep.is_admin.into_iter().next(),
            is_bot: intermediate_rep.is_bot.into_iter().next(),
            is_active: intermediate_rep.is_active.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<EntityEdit> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<EntityEdit>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<EntityEdit>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for EntityEdit - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EntityEdit> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <EntityEdit as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into EntityEdit - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct EntityEdit {
    /// Unique UUID for this specific edit object.
    #[serde(rename = "edit_id")]
    pub edit_id: String,

    /// Fatcat identifier of the entity this edit is mutating.
    #[serde(rename = "ident")]
    pub ident: String,

    /// Entity revision that this edit will set the entity to. May be `null` in the case of deletions.
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// Revision of entity just before this edit. May be used in the future to prevent edit race conditions.
    #[serde(rename = "prev_revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prev_revision: Option<String>,

    /// When an edit is to merge entities (redirect one to another), this is the entity fatcat identifier for the target entity.
    #[serde(rename = "redirect_ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect_ident: Option<String>,

    /// Editgroup identifier that this edit is part of.
    #[serde(rename = "editgroup_id")]
    pub editgroup_id: String,

    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl EntityEdit {
    pub fn new(edit_id: String, ident: String, editgroup_id: String) -> EntityEdit {
        EntityEdit {
            edit_id: edit_id,
            ident: ident,
            revision: None,
            prev_revision: None,
            redirect_ident: None,
            editgroup_id: editgroup_id,
            extra: None,
        }
    }
}

/// Converts the EntityEdit value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for EntityEdit {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("edit_id".to_string());
        params.push(self.edit_id.to_string());

        params.push("ident".to_string());
        params.push(self.ident.to_string());

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref prev_revision) = self.prev_revision {
            params.push("prev_revision".to_string());
            params.push(prev_revision.to_string());
        }

        if let Some(ref redirect_ident) = self.redirect_ident {
            params.push("redirect_ident".to_string());
            params.push(redirect_ident.to_string());
        }

        params.push("editgroup_id".to_string());
        params.push(self.editgroup_id.to_string());

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a EntityEdit value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for EntityEdit {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub edit_id: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub prev_revision: Vec<String>,
            pub redirect_ident: Vec<String>,
            pub editgroup_id: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing EntityEdit".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "edit_id" => intermediate_rep
                        .edit_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "prev_revision" => intermediate_rep
                        .prev_revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect_ident" => intermediate_rep
                        .redirect_ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "editgroup_id" => intermediate_rep
                        .editgroup_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in EntityEdit"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing EntityEdit".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(EntityEdit {
            edit_id: intermediate_rep
                .edit_id
                .into_iter()
                .next()
                .ok_or("edit_id missing in EntityEdit".to_string())?,
            ident: intermediate_rep
                .ident
                .into_iter()
                .next()
                .ok_or("ident missing in EntityEdit".to_string())?,
            revision: intermediate_rep.revision.into_iter().next(),
            prev_revision: intermediate_rep.prev_revision.into_iter().next(),
            redirect_ident: intermediate_rep.redirect_ident.into_iter().next(),
            editgroup_id: intermediate_rep
                .editgroup_id
                .into_iter()
                .next()
                .ok_or("editgroup_id missing in EntityEdit".to_string())?,
            extra: intermediate_rep.extra.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<EntityHistoryEntry> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<EntityHistoryEntry>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<EntityHistoryEntry>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for EntityHistoryEntry - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<EntityHistoryEntry>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <EntityHistoryEntry as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into EntityHistoryEntry - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct EntityHistoryEntry {
    #[serde(rename = "edit")]
    pub edit: models::EntityEdit,

    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "changelog_entry")]
    pub changelog_entry: models::ChangelogEntry,
}

impl EntityHistoryEntry {
    pub fn new(
        edit: models::EntityEdit,
        editgroup: models::Editgroup,
        changelog_entry: models::ChangelogEntry,
    ) -> EntityHistoryEntry {
        EntityHistoryEntry {
            edit: edit,
            editgroup: editgroup,
            changelog_entry: changelog_entry,
        }
    }
}

/// Converts the EntityHistoryEntry value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for EntityHistoryEntry {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping edit in query parameter serialization

        // Skipping editgroup in query parameter serialization

        // Skipping changelog_entry in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a EntityHistoryEntry value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for EntityHistoryEntry {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub edit: Vec<models::EntityEdit>,
            pub editgroup: Vec<models::Editgroup>,
            pub changelog_entry: Vec<models::ChangelogEntry>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing EntityHistoryEntry".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "edit" => intermediate_rep
                        .edit
                        .push(models::EntityEdit::from_str(val).map_err(|x| format!("{}", x))?),
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "changelog_entry" => intermediate_rep
                        .changelog_entry
                        .push(models::ChangelogEntry::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing EntityHistoryEntry".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(EntityHistoryEntry {
            edit: intermediate_rep
                .edit
                .into_iter()
                .next()
                .ok_or("edit missing in EntityHistoryEntry".to_string())?,
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in EntityHistoryEntry".to_string())?,
            changelog_entry: intermediate_rep
                .changelog_entry
                .into_iter()
                .next()
                .ok_or("changelog_entry missing in EntityHistoryEntry".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ErrorResponse> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ErrorResponse>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ErrorResponse>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ErrorResponse - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ErrorResponse> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ErrorResponse as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ErrorResponse - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ErrorResponse {
    #[serde(rename = "success")]
    pub success: bool,

    #[serde(rename = "error")]
    pub error: String,

    #[serde(rename = "message")]
    pub message: String,
}

impl ErrorResponse {
    pub fn new(success: bool, error: String, message: String) -> ErrorResponse {
        ErrorResponse {
            success: success,
            error: error,
            message: message,
        }
    }
}

/// Converts the ErrorResponse value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ErrorResponse {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("success".to_string());
        params.push(self.success.to_string());

        params.push("error".to_string());
        params.push(self.error.to_string());

        params.push("message".to_string());
        params.push(self.message.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ErrorResponse value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ErrorResponse {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub success: Vec<bool>,
            pub error: Vec<String>,
            pub message: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ErrorResponse".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "success" => intermediate_rep
                        .success
                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
                    "error" => intermediate_rep
                        .error
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "message" => intermediate_rep
                        .message
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ErrorResponse".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ErrorResponse {
            success: intermediate_rep
                .success
                .into_iter()
                .next()
                .ok_or("success missing in ErrorResponse".to_string())?,
            error: intermediate_rep
                .error
                .into_iter()
                .next()
                .ok_or("error missing in ErrorResponse".to_string())?,
            message: intermediate_rep
                .message
                .into_iter()
                .next()
                .ok_or("message missing in ErrorResponse".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FileAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FileAutoBatch>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FileAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FileAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileAutoBatch> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FileAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FileAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FileAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::FileEntity>,
}

impl FileAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::FileEntity>,
    ) -> FileAutoBatch {
        FileAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the FileAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FileAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FileAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FileAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::FileEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FileAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FileAutoBatch"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FileAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FileAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in FileAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in FileAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FileEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FileEntity>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FileEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FileEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileEntity> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FileEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FileEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FileEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Size of file in bytes. Non-zero.
    #[serde(rename = "size")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,

    /// MD5 hash of data, in hex encoding
    #[serde(rename = "md5")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub md5: Option<String>,

    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha1: Option<String>,

    /// SHA-256 hash of data, in hex encoding
    #[serde(rename = "sha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,

    #[serde(rename = "urls")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub urls: Option<Vec<models::FileUrl>>,

    #[serde(rename = "mimetype")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mimetype: Option<String>,

    /// Set of identifier of release entities this file represents a full manifestation of. Usually a single release, but some files contain content of multiple full releases (eg, an issue of a journal).
    #[serde(rename = "release_ids")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_ids: Option<Vec<String>>,

    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::ReleaseEntity>>,
}

impl FileEntity {
    pub fn new() -> FileEntity {
        FileEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
            size: None,
            md5: None,
            sha1: None,
            sha256: None,
            urls: None,
            mimetype: None,
            release_ids: None,
            releases: None,
        }
    }
}

/// Converts the FileEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FileEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        if let Some(ref size) = self.size {
            params.push("size".to_string());
            params.push(size.to_string());
        }

        if let Some(ref md5) = self.md5 {
            params.push("md5".to_string());
            params.push(md5.to_string());
        }

        if let Some(ref sha1) = self.sha1 {
            params.push("sha1".to_string());
            params.push(sha1.to_string());
        }

        if let Some(ref sha256) = self.sha256 {
            params.push("sha256".to_string());
            params.push(sha256.to_string());
        }

        // Skipping urls in query parameter serialization

        if let Some(ref mimetype) = self.mimetype {
            params.push("mimetype".to_string());
            params.push(mimetype.to_string());
        }

        if let Some(ref release_ids) = self.release_ids {
            params.push("release_ids".to_string());
            params.push(
                release_ids
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
                    .to_string(),
            );
        }

        // Skipping releases in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FileEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FileEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub size: Vec<i64>,
            pub md5: Vec<String>,
            pub sha1: Vec<String>,
            pub sha256: Vec<String>,
            pub urls: Vec<Vec<models::FileUrl>>,
            pub mimetype: Vec<String>,
            pub release_ids: Vec<Vec<String>>,
            pub releases: Vec<Vec<models::ReleaseEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FileEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FileEntity"
                                .to_string(),
                        )
                    }
                    "edit_extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FileEntity"
                                .to_string(),
                        )
                    }
                    "size" => intermediate_rep
                        .size
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "md5" => intermediate_rep
                        .md5
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "sha1" => intermediate_rep
                        .sha1
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "sha256" => intermediate_rep
                        .sha256
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "urls" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FileEntity"
                                .to_string(),
                        )
                    }
                    "mimetype" => intermediate_rep
                        .mimetype
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "release_ids" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FileEntity"
                                .to_string(),
                        )
                    }
                    "releases" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FileEntity"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FileEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FileEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
            size: intermediate_rep.size.into_iter().next(),
            md5: intermediate_rep.md5.into_iter().next(),
            sha1: intermediate_rep.sha1.into_iter().next(),
            sha256: intermediate_rep.sha256.into_iter().next(),
            urls: intermediate_rep.urls.into_iter().next(),
            mimetype: intermediate_rep.mimetype.into_iter().next(),
            release_ids: intermediate_rep.release_ids.into_iter().next(),
            releases: intermediate_rep.releases.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FileUrl> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FileUrl>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FileUrl>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FileUrl - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileUrl> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FileUrl as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FileUrl - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FileUrl {
    /// URL/URI pointing directly to a machine retrievable copy of this exact file.
    #[serde(rename = "url")]
    pub url: String,

    /// Indicates type of host this URL points to. Eg, \"publisher\", \"repository\", \"webarchive\". See guide for list of acceptable values.
    #[serde(rename = "rel")]
    pub rel: String,
}

impl FileUrl {
    pub fn new(url: String, rel: String) -> FileUrl {
        FileUrl { url: url, rel: rel }
    }
}

/// Converts the FileUrl value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FileUrl {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("url".to_string());
        params.push(self.url.to_string());

        params.push("rel".to_string());
        params.push(self.rel.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FileUrl value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FileUrl {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub url: Vec<String>,
            pub rel: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FileUrl".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "url" => intermediate_rep
                        .url
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "rel" => intermediate_rep
                        .rel
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FileUrl".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FileUrl {
            url: intermediate_rep
                .url
                .into_iter()
                .next()
                .ok_or("url missing in FileUrl".to_string())?,
            rel: intermediate_rep
                .rel
                .into_iter()
                .next()
                .ok_or("rel missing in FileUrl".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FilesetAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FilesetAutoBatch>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FilesetAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FilesetAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<FilesetAutoBatch>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FilesetAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FilesetAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FilesetAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::FilesetEntity>,
}

impl FilesetAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::FilesetEntity>,
    ) -> FilesetAutoBatch {
        FilesetAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the FilesetAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FilesetAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FilesetAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FilesetAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::FilesetEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FilesetAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in FilesetAutoBatch"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FilesetAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FilesetAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in FilesetAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in FilesetAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FilesetEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FilesetEntity>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FilesetEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FilesetEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetEntity> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FilesetEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FilesetEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FilesetEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    #[serde(rename = "manifest")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub manifest: Option<Vec<models::FilesetFile>>,

    #[serde(rename = "urls")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub urls: Option<Vec<models::FilesetUrl>>,

    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
    #[serde(rename = "release_ids")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_ids: Option<Vec<String>>,

    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::ReleaseEntity>>,
}

impl FilesetEntity {
    pub fn new() -> FilesetEntity {
        FilesetEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
            manifest: None,
            urls: None,
            release_ids: None,
            releases: None,
        }
    }
}

/// Converts the FilesetEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FilesetEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        // Skipping manifest in query parameter serialization

        // Skipping urls in query parameter serialization

        if let Some(ref release_ids) = self.release_ids {
            params.push("release_ids".to_string());
            params.push(
                release_ids
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
                    .to_string(),
            );
        }

        // Skipping releases in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FilesetEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FilesetEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub manifest: Vec<Vec<models::FilesetFile>>,
            pub urls: Vec<Vec<models::FilesetUrl>>,
            pub release_ids: Vec<Vec<String>>,
            pub releases: Vec<Vec<models::ReleaseEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FilesetEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetEntity"
                                .to_string(),
                        )
                    }
                    "edit_extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetEntity"
                                .to_string(),
                        )
                    }
                    "manifest" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetEntity"
                                .to_string(),
                        )
                    }
                    "urls" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetEntity"
                                .to_string(),
                        )
                    }
                    "release_ids" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetEntity"
                                .to_string(),
                        )
                    }
                    "releases" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetEntity"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FilesetEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FilesetEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
            manifest: intermediate_rep.manifest.into_iter().next(),
            urls: intermediate_rep.urls.into_iter().next(),
            release_ids: intermediate_rep.release_ids.into_iter().next(),
            releases: intermediate_rep.releases.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FilesetFile> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FilesetFile>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FilesetFile>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FilesetFile - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetFile> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FilesetFile as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FilesetFile - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FilesetFile {
    /// Path name of file within this fileset (eg, directory)
    #[serde(rename = "path")]
    pub path: String,

    /// File size in bytes
    #[serde(rename = "size")]
    pub size: i64,

    /// MD5 hash of data, in hex encoding
    #[serde(rename = "md5")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub md5: Option<String>,

    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha1: Option<String>,

    /// SHA-256 hash of data, in hex encoding
    #[serde(rename = "sha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,

    /// Free-form additional metadata about this specific file in the set. Eg, `mimetype`. See guide for nomative (but unenforced) schema fields.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl FilesetFile {
    pub fn new(path: String, size: i64) -> FilesetFile {
        FilesetFile {
            path: path,
            size: size,
            md5: None,
            sha1: None,
            sha256: None,
            extra: None,
        }
    }
}

/// Converts the FilesetFile value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FilesetFile {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("path".to_string());
        params.push(self.path.to_string());

        params.push("size".to_string());
        params.push(self.size.to_string());

        if let Some(ref md5) = self.md5 {
            params.push("md5".to_string());
            params.push(md5.to_string());
        }

        if let Some(ref sha1) = self.sha1 {
            params.push("sha1".to_string());
            params.push(sha1.to_string());
        }

        if let Some(ref sha256) = self.sha256 {
            params.push("sha256".to_string());
            params.push(sha256.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FilesetFile value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FilesetFile {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub path: Vec<String>,
            pub size: Vec<i64>,
            pub md5: Vec<String>,
            pub sha1: Vec<String>,
            pub sha256: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FilesetFile".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "path" => intermediate_rep
                        .path
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "size" => intermediate_rep
                        .size
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "md5" => intermediate_rep
                        .md5
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "sha1" => intermediate_rep
                        .sha1
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "sha256" => intermediate_rep
                        .sha256
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in FilesetFile"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FilesetFile".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FilesetFile {
            path: intermediate_rep
                .path
                .into_iter()
                .next()
                .ok_or("path missing in FilesetFile".to_string())?,
            size: intermediate_rep
                .size
                .into_iter()
                .next()
                .ok_or("size missing in FilesetFile".to_string())?,
            md5: intermediate_rep.md5.into_iter().next(),
            sha1: intermediate_rep.sha1.into_iter().next(),
            sha256: intermediate_rep.sha256.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<FilesetUrl> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<FilesetUrl>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<FilesetUrl>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for FilesetUrl - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetUrl> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <FilesetUrl as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into FilesetUrl - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct FilesetUrl {
    #[serde(rename = "url")]
    pub url: String,

    /// Indicates type of host this URL points to. See guide for list of acceptable values.
    #[serde(rename = "rel")]
    pub rel: String,
}

impl FilesetUrl {
    pub fn new(url: String, rel: String) -> FilesetUrl {
        FilesetUrl { url: url, rel: rel }
    }
}

/// Converts the FilesetUrl value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for FilesetUrl {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("url".to_string());
        params.push(self.url.to_string());

        params.push("rel".to_string());
        params.push(self.rel.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a FilesetUrl value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for FilesetUrl {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub url: Vec<String>,
            pub rel: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing FilesetUrl".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "url" => intermediate_rep
                        .url
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "rel" => intermediate_rep
                        .rel
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing FilesetUrl".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(FilesetUrl {
            url: intermediate_rep
                .url
                .into_iter()
                .next()
                .ok_or("url missing in FilesetUrl".to_string())?,
            rel: intermediate_rep
                .rel
                .into_iter()
                .next()
                .ok_or("rel missing in FilesetUrl".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ReleaseAbstract> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAbstract>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ReleaseAbstract>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ReleaseAbstract - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<ReleaseAbstract>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ReleaseAbstract as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ReleaseAbstract - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ReleaseAbstract {
    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha1: Option<String>,

    /// Abstract content. May be encoded, as per `mimetype` field, but only string/text content may be included.
    #[serde(rename = "content")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,

    /// Mimetype of abstract contents. `text/plain` is the default if content isn't encoded.
    #[serde(rename = "mimetype")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mimetype: Option<String>,

    /// ISO language code of the abstract. Same semantics as release `language` field.
    #[serde(rename = "lang")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<String>,
}

impl ReleaseAbstract {
    pub fn new() -> ReleaseAbstract {
        ReleaseAbstract {
            sha1: None,
            content: None,
            mimetype: None,
            lang: None,
        }
    }
}

/// Converts the ReleaseAbstract value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ReleaseAbstract {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref sha1) = self.sha1 {
            params.push("sha1".to_string());
            params.push(sha1.to_string());
        }

        if let Some(ref content) = self.content {
            params.push("content".to_string());
            params.push(content.to_string());
        }

        if let Some(ref mimetype) = self.mimetype {
            params.push("mimetype".to_string());
            params.push(mimetype.to_string());
        }

        if let Some(ref lang) = self.lang {
            params.push("lang".to_string());
            params.push(lang.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAbstract value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ReleaseAbstract {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub sha1: Vec<String>,
            pub content: Vec<String>,
            pub mimetype: Vec<String>,
            pub lang: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ReleaseAbstract".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "sha1" => intermediate_rep
                        .sha1
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "content" => intermediate_rep
                        .content
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "mimetype" => intermediate_rep
                        .mimetype
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "lang" => intermediate_rep
                        .lang
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ReleaseAbstract".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ReleaseAbstract {
            sha1: intermediate_rep.sha1.into_iter().next(),
            content: intermediate_rep.content.into_iter().next(),
            mimetype: intermediate_rep.mimetype.into_iter().next(),
            lang: intermediate_rep.lang.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ReleaseAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAutoBatch>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ReleaseAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ReleaseAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<ReleaseAutoBatch>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ReleaseAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ReleaseAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ReleaseAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::ReleaseEntity>,
}

impl ReleaseAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::ReleaseEntity>,
    ) -> ReleaseAutoBatch {
        ReleaseAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the ReleaseAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ReleaseAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ReleaseAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::ReleaseEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ReleaseAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in ReleaseAutoBatch"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ReleaseAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ReleaseAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in ReleaseAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in ReleaseAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ReleaseContrib> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseContrib>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ReleaseContrib>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ReleaseContrib - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseContrib> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ReleaseContrib as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ReleaseContrib - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ReleaseContrib {
    /// Internally assigned zero-indexed sequence number of contribution. Authors should come first; this encodes the order of attriubtion.
    #[serde(rename = "index")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index: Option<i64>,

    /// If known, indicates the creator entity this contribution was made by.
    #[serde(rename = "creator_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator_id: Option<String>,

    #[serde(rename = "creator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator: Option<models::CreatorEntity>,

    /// Full name of the contributor as typeset in the release.
    #[serde(rename = "raw_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_name: Option<String>,

    /// In English commonly the first name, but ordering is context and culture specific.
    #[serde(rename = "given_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<String>,

    /// In English commonly the last, or family name, but ordering is context and culture specific.
    #[serde(rename = "surname")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub surname: Option<String>,

    /// Short string (slug) indicating type of contribution (eg, \"author\", \"translator\"). See guide for list of accpeted values.
    #[serde(rename = "role")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,

    /// Raw affiliation string as displayed in text
    #[serde(rename = "raw_affiliation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_affiliation: Option<String>,

    /// Additional free-form JSON metadata about this contributor/contribution. See guide for normative schema.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl ReleaseContrib {
    pub fn new() -> ReleaseContrib {
        ReleaseContrib {
            index: None,
            creator_id: None,
            creator: None,
            raw_name: None,
            given_name: None,
            surname: None,
            role: None,
            raw_affiliation: None,
            extra: None,
        }
    }
}

/// Converts the ReleaseContrib value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ReleaseContrib {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref index) = self.index {
            params.push("index".to_string());
            params.push(index.to_string());
        }

        if let Some(ref creator_id) = self.creator_id {
            params.push("creator_id".to_string());
            params.push(creator_id.to_string());
        }

        // Skipping creator in query parameter serialization

        if let Some(ref raw_name) = self.raw_name {
            params.push("raw_name".to_string());
            params.push(raw_name.to_string());
        }

        if let Some(ref given_name) = self.given_name {
            params.push("given_name".to_string());
            params.push(given_name.to_string());
        }

        if let Some(ref surname) = self.surname {
            params.push("surname".to_string());
            params.push(surname.to_string());
        }

        if let Some(ref role) = self.role {
            params.push("role".to_string());
            params.push(role.to_string());
        }

        if let Some(ref raw_affiliation) = self.raw_affiliation {
            params.push("raw_affiliation".to_string());
            params.push(raw_affiliation.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseContrib value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ReleaseContrib {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub index: Vec<i64>,
            pub creator_id: Vec<String>,
            pub creator: Vec<models::CreatorEntity>,
            pub raw_name: Vec<String>,
            pub given_name: Vec<String>,
            pub surname: Vec<String>,
            pub role: Vec<String>,
            pub raw_affiliation: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ReleaseContrib".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "index" => intermediate_rep
                        .index
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "creator_id" => intermediate_rep
                        .creator_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "creator" => intermediate_rep
                        .creator
                        .push(models::CreatorEntity::from_str(val).map_err(|x| format!("{}", x))?),
                    "raw_name" => intermediate_rep
                        .raw_name
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "given_name" => intermediate_rep
                        .given_name
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "surname" => intermediate_rep
                        .surname
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "role" => intermediate_rep
                        .role
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "raw_affiliation" => intermediate_rep
                        .raw_affiliation
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseContrib"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ReleaseContrib".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ReleaseContrib {
            index: intermediate_rep.index.into_iter().next(),
            creator_id: intermediate_rep.creator_id.into_iter().next(),
            creator: intermediate_rep.creator.into_iter().next(),
            raw_name: intermediate_rep.raw_name.into_iter().next(),
            given_name: intermediate_rep.given_name.into_iter().next(),
            surname: intermediate_rep.surname.into_iter().next(),
            role: intermediate_rep.role.into_iter().next(),
            raw_affiliation: intermediate_rep.raw_affiliation.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ReleaseEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseEntity>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ReleaseEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ReleaseEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseEntity> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ReleaseEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ReleaseEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ReleaseEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Required for valid entities. The title used in citations and for display. Sometimes the English translation of title e even if release content is not English.
    #[serde(rename = "title")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,

    /// Subtitle of release. In many cases, better to merge with title than include as separate field (unless combined title would be very long). See guide for details.
    #[serde(rename = "subtitle")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subtitle: Option<String>,

    /// Title in original language if `title` field has been translated. See guide for details.
    #[serde(rename = "original_title")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub original_title: Option<String>,

    /// Identifier of work this release is part of. In creation (POST) requests, a work entity will be created automatically if this field is not set.
    #[serde(rename = "work_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_id: Option<String>,

    #[serde(rename = "container")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container: Option<models::ContainerEntity>,

    /// Complete file entities identified by `file_ids` field. Only included in GET responses when `files` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "files")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<models::FileEntity>>,

    /// Complete file entities identified by `filesets_ids` field. Only included in GET responses when `filesets` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "filesets")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filesets: Option<Vec<models::FilesetEntity>>,

    /// Complete webcapture entities identified by `webcapture_ids` field. Only included in GET responses when `webcaptures` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "webcaptures")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webcaptures: Option<Vec<models::WebcaptureEntity>>,

    /// Used to link this release to a container entity that the release was published as part of.
    #[serde(rename = "container_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_id: Option<String>,

    /// \"Type\" or \"medium\" that this release is published as. See guide for valid values.
    #[serde(rename = "release_type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_type: Option<String>,

    /// The stage of publication of this specific release. See guide for valid values and semantics.
    #[serde(rename = "release_stage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_stage: Option<String>,

    /// Full date when this release was formally published. ISO format, like `2019-03-05`. See guide for semantics.
    #[serde(rename = "release_date")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_date: Option<chrono::DateTime<chrono::Utc>>,

    /// Year when this release was formally published. Must match `release_date` if that field is set; this field exists because sometimes only the year is known.
    #[serde(rename = "release_year")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_year: Option<i64>,

    /// Type of withdrawl or retraction of this release, if applicable. If release has not been withdrawn, should be `null` (aka, not set, not the string \"null\" or an empty string).
    #[serde(rename = "withdrawn_status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawn_status: Option<String>,

    /// Full date when this release was formally withdrawn (if applicable). ISO format, like `release_date`.
    #[serde(rename = "withdrawn_date")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawn_date: Option<chrono::DateTime<chrono::Utc>>,

    /// Year corresponding with `withdrawn_date` like `release_year`/`release_date`.
    #[serde(rename = "withdrawn_year")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawn_year: Option<i64>,

    #[serde(rename = "ext_ids")]
    pub ext_ids: models::ReleaseExtIds,

    /// Volume number of container that this release was published in. Often corresponds to the \"Nth\" year of publication, but can be any string. See guide.
    #[serde(rename = "volume")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume: Option<String>,

    /// Issue number of volume/container that this release was published in. Sometimes coresponds to a month number in the year, but can be any string. See guide.
    #[serde(rename = "issue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issue: Option<String>,

    /// Either a single page number (\"first page\") or a range of pages separated by a dash (\"-\"). See guide for details.
    #[serde(rename = "pages")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pages: Option<String>,

    /// For, eg, technical reports, which are published in series or assigned some other institutional or container-specific identifier.
    #[serde(rename = "number")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<String>,

    /// For, eg, updated technical reports or software packages, where the version string may be the only field disambiguating between releases.
    #[serde(rename = "version")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,

    /// Name, usually English, of the entity or institution responsible for publication of this release. Not necessarily the imprint/brand. See guide.
    #[serde(rename = "publisher")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<String>,

    /// Primary language of the content of the full release. Two-letter RFC1766/ISO639-1 language code, with some custom extensions/additions. See guide.
    #[serde(rename = "language")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,

    /// Short string (slug) name of license under which release is openly published (if applicable).
    #[serde(rename = "license_slug")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub license_slug: Option<String>,

    #[serde(rename = "contribs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contribs: Option<Vec<models::ReleaseContrib>>,

    #[serde(rename = "refs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub refs: Option<Vec<models::ReleaseRef>>,

    #[serde(rename = "abstracts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub abstracts: Option<Vec<models::ReleaseAbstract>>,
}

impl ReleaseEntity {
    pub fn new(ext_ids: models::ReleaseExtIds) -> ReleaseEntity {
        ReleaseEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
            title: None,
            subtitle: None,
            original_title: None,
            work_id: None,
            container: None,
            files: None,
            filesets: None,
            webcaptures: None,
            container_id: None,
            release_type: None,
            release_stage: None,
            release_date: None,
            release_year: None,
            withdrawn_status: None,
            withdrawn_date: None,
            withdrawn_year: None,
            ext_ids: ext_ids,
            volume: None,
            issue: None,
            pages: None,
            number: None,
            version: None,
            publisher: None,
            language: None,
            license_slug: None,
            contribs: None,
            refs: None,
            abstracts: None,
        }
    }
}

/// Converts the ReleaseEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ReleaseEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        if let Some(ref title) = self.title {
            params.push("title".to_string());
            params.push(title.to_string());
        }

        if let Some(ref subtitle) = self.subtitle {
            params.push("subtitle".to_string());
            params.push(subtitle.to_string());
        }

        if let Some(ref original_title) = self.original_title {
            params.push("original_title".to_string());
            params.push(original_title.to_string());
        }

        if let Some(ref work_id) = self.work_id {
            params.push("work_id".to_string());
            params.push(work_id.to_string());
        }

        // Skipping container in query parameter serialization

        // Skipping files in query parameter serialization

        // Skipping filesets in query parameter serialization

        // Skipping webcaptures in query parameter serialization

        if let Some(ref container_id) = self.container_id {
            params.push("container_id".to_string());
            params.push(container_id.to_string());
        }

        if let Some(ref release_type) = self.release_type {
            params.push("release_type".to_string());
            params.push(release_type.to_string());
        }

        if let Some(ref release_stage) = self.release_stage {
            params.push("release_stage".to_string());
            params.push(release_stage.to_string());
        }

        // Skipping release_date in query parameter serialization

        if let Some(ref release_year) = self.release_year {
            params.push("release_year".to_string());
            params.push(release_year.to_string());
        }

        if let Some(ref withdrawn_status) = self.withdrawn_status {
            params.push("withdrawn_status".to_string());
            params.push(withdrawn_status.to_string());
        }

        // Skipping withdrawn_date in query parameter serialization

        if let Some(ref withdrawn_year) = self.withdrawn_year {
            params.push("withdrawn_year".to_string());
            params.push(withdrawn_year.to_string());
        }

        // Skipping ext_ids in query parameter serialization

        if let Some(ref volume) = self.volume {
            params.push("volume".to_string());
            params.push(volume.to_string());
        }

        if let Some(ref issue) = self.issue {
            params.push("issue".to_string());
            params.push(issue.to_string());
        }

        if let Some(ref pages) = self.pages {
            params.push("pages".to_string());
            params.push(pages.to_string());
        }

        if let Some(ref number) = self.number {
            params.push("number".to_string());
            params.push(number.to_string());
        }

        if let Some(ref version) = self.version {
            params.push("version".to_string());
            params.push(version.to_string());
        }

        if let Some(ref publisher) = self.publisher {
            params.push("publisher".to_string());
            params.push(publisher.to_string());
        }

        if let Some(ref language) = self.language {
            params.push("language".to_string());
            params.push(language.to_string());
        }

        if let Some(ref license_slug) = self.license_slug {
            params.push("license_slug".to_string());
            params.push(license_slug.to_string());
        }

        // Skipping contribs in query parameter serialization

        // Skipping refs in query parameter serialization

        // Skipping abstracts in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ReleaseEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub title: Vec<String>,
            pub subtitle: Vec<String>,
            pub original_title: Vec<String>,
            pub work_id: Vec<String>,
            pub container: Vec<models::ContainerEntity>,
            pub files: Vec<Vec<models::FileEntity>>,
            pub filesets: Vec<Vec<models::FilesetEntity>>,
            pub webcaptures: Vec<Vec<models::WebcaptureEntity>>,
            pub container_id: Vec<String>,
            pub release_type: Vec<String>,
            pub release_stage: Vec<String>,
            pub release_date: Vec<chrono::DateTime<chrono::Utc>>,
            pub release_year: Vec<i64>,
            pub withdrawn_status: Vec<String>,
            pub withdrawn_date: Vec<chrono::DateTime<chrono::Utc>>,
            pub withdrawn_year: Vec<i64>,
            pub ext_ids: Vec<models::ReleaseExtIds>,
            pub volume: Vec<String>,
            pub issue: Vec<String>,
            pub pages: Vec<String>,
            pub number: Vec<String>,
            pub version: Vec<String>,
            pub publisher: Vec<String>,
            pub language: Vec<String>,
            pub license_slug: Vec<String>,
            pub contribs: Vec<Vec<models::ReleaseContrib>>,
            pub refs: Vec<Vec<models::ReleaseRef>>,
            pub abstracts: Vec<Vec<models::ReleaseAbstract>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ReleaseEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "edit_extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "title" => intermediate_rep
                        .title
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "subtitle" => intermediate_rep
                        .subtitle
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "original_title" => intermediate_rep
                        .original_title
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "work_id" => intermediate_rep
                        .work_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "container" => intermediate_rep.container.push(
                        models::ContainerEntity::from_str(val).map_err(|x| format!("{}", x))?,
                    ),
                    "files" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "filesets" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "webcaptures" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "container_id" => intermediate_rep
                        .container_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "release_type" => intermediate_rep
                        .release_type
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "release_stage" => intermediate_rep
                        .release_stage
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "release_date" => intermediate_rep.release_date.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "release_year" => intermediate_rep
                        .release_year
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "withdrawn_status" => intermediate_rep
                        .withdrawn_status
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "withdrawn_date" => intermediate_rep.withdrawn_date.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "withdrawn_year" => intermediate_rep
                        .withdrawn_year
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "ext_ids" => intermediate_rep
                        .ext_ids
                        .push(models::ReleaseExtIds::from_str(val).map_err(|x| format!("{}", x))?),
                    "volume" => intermediate_rep
                        .volume
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "issue" => intermediate_rep
                        .issue
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "pages" => intermediate_rep
                        .pages
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "number" => intermediate_rep
                        .number
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "version" => intermediate_rep
                        .version
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "publisher" => intermediate_rep
                        .publisher
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "language" => intermediate_rep
                        .language
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "license_slug" => intermediate_rep
                        .license_slug
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "contribs" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "refs" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    "abstracts" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseEntity"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ReleaseEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ReleaseEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
            title: intermediate_rep.title.into_iter().next(),
            subtitle: intermediate_rep.subtitle.into_iter().next(),
            original_title: intermediate_rep.original_title.into_iter().next(),
            work_id: intermediate_rep.work_id.into_iter().next(),
            container: intermediate_rep.container.into_iter().next(),
            files: intermediate_rep.files.into_iter().next(),
            filesets: intermediate_rep.filesets.into_iter().next(),
            webcaptures: intermediate_rep.webcaptures.into_iter().next(),
            container_id: intermediate_rep.container_id.into_iter().next(),
            release_type: intermediate_rep.release_type.into_iter().next(),
            release_stage: intermediate_rep.release_stage.into_iter().next(),
            release_date: intermediate_rep.release_date.into_iter().next(),
            release_year: intermediate_rep.release_year.into_iter().next(),
            withdrawn_status: intermediate_rep.withdrawn_status.into_iter().next(),
            withdrawn_date: intermediate_rep.withdrawn_date.into_iter().next(),
            withdrawn_year: intermediate_rep.withdrawn_year.into_iter().next(),
            ext_ids: intermediate_rep
                .ext_ids
                .into_iter()
                .next()
                .ok_or("ext_ids missing in ReleaseEntity".to_string())?,
            volume: intermediate_rep.volume.into_iter().next(),
            issue: intermediate_rep.issue.into_iter().next(),
            pages: intermediate_rep.pages.into_iter().next(),
            number: intermediate_rep.number.into_iter().next(),
            version: intermediate_rep.version.into_iter().next(),
            publisher: intermediate_rep.publisher.into_iter().next(),
            language: intermediate_rep.language.into_iter().next(),
            license_slug: intermediate_rep.license_slug.into_iter().next(),
            contribs: intermediate_rep.contribs.into_iter().next(),
            refs: intermediate_rep.refs.into_iter().next(),
            abstracts: intermediate_rep.abstracts.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ReleaseExtIds> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseExtIds>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ReleaseExtIds>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ReleaseExtIds - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseExtIds> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ReleaseExtIds as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ReleaseExtIds - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ReleaseExtIds {
    /// Digital Object Identifier (DOI), mostly for published papers and datasets. Should be registered and resolvable via https://doi.org/
    #[serde(rename = "doi")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub doi: Option<String>,

    /// Wikidata entity QID
    #[serde(rename = "wikidata_qid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wikidata_qid: Option<String>,

    /// ISBN-13, for books. Usually not set for chapters. ISBN-10 should be converted to ISBN-13.
    #[serde(rename = "isbn13")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isbn13: Option<String>,

    /// PubMed Identifier
    #[serde(rename = "pmid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pmid: Option<String>,

    /// PubMed Central Identifier
    #[serde(rename = "pmcid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pmcid: Option<String>,

    /// CORE (https://core.ac.uk) identifier
    #[serde(rename = "core")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub core: Option<String>,

    /// arXiv (https://arxiv.org) identifier; must include version
    #[serde(rename = "arxiv")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arxiv: Option<String>,

    /// JSTOR work identifier
    #[serde(rename = "jstor")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jstor: Option<String>,

    /// ARK identifier
    #[serde(rename = "ark")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ark: Option<String>,

    /// Microsoft Academic Graph identifier
    #[serde(rename = "mag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mag: Option<String>,
}

impl ReleaseExtIds {
    pub fn new() -> ReleaseExtIds {
        ReleaseExtIds {
            doi: None,
            wikidata_qid: None,
            isbn13: None,
            pmid: None,
            pmcid: None,
            core: None,
            arxiv: None,
            jstor: None,
            ark: None,
            mag: None,
        }
    }
}

/// Converts the ReleaseExtIds value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ReleaseExtIds {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref doi) = self.doi {
            params.push("doi".to_string());
            params.push(doi.to_string());
        }

        if let Some(ref wikidata_qid) = self.wikidata_qid {
            params.push("wikidata_qid".to_string());
            params.push(wikidata_qid.to_string());
        }

        if let Some(ref isbn13) = self.isbn13 {
            params.push("isbn13".to_string());
            params.push(isbn13.to_string());
        }

        if let Some(ref pmid) = self.pmid {
            params.push("pmid".to_string());
            params.push(pmid.to_string());
        }

        if let Some(ref pmcid) = self.pmcid {
            params.push("pmcid".to_string());
            params.push(pmcid.to_string());
        }

        if let Some(ref core) = self.core {
            params.push("core".to_string());
            params.push(core.to_string());
        }

        if let Some(ref arxiv) = self.arxiv {
            params.push("arxiv".to_string());
            params.push(arxiv.to_string());
        }

        if let Some(ref jstor) = self.jstor {
            params.push("jstor".to_string());
            params.push(jstor.to_string());
        }

        if let Some(ref ark) = self.ark {
            params.push("ark".to_string());
            params.push(ark.to_string());
        }

        if let Some(ref mag) = self.mag {
            params.push("mag".to_string());
            params.push(mag.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseExtIds value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ReleaseExtIds {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub doi: Vec<String>,
            pub wikidata_qid: Vec<String>,
            pub isbn13: Vec<String>,
            pub pmid: Vec<String>,
            pub pmcid: Vec<String>,
            pub core: Vec<String>,
            pub arxiv: Vec<String>,
            pub jstor: Vec<String>,
            pub ark: Vec<String>,
            pub mag: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ReleaseExtIds".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "doi" => intermediate_rep
                        .doi
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "wikidata_qid" => intermediate_rep
                        .wikidata_qid
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "isbn13" => intermediate_rep
                        .isbn13
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "pmid" => intermediate_rep
                        .pmid
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "pmcid" => intermediate_rep
                        .pmcid
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "core" => intermediate_rep
                        .core
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "arxiv" => intermediate_rep
                        .arxiv
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "jstor" => intermediate_rep
                        .jstor
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ark" => intermediate_rep
                        .ark
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "mag" => intermediate_rep
                        .mag
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ReleaseExtIds".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ReleaseExtIds {
            doi: intermediate_rep.doi.into_iter().next(),
            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
            isbn13: intermediate_rep.isbn13.into_iter().next(),
            pmid: intermediate_rep.pmid.into_iter().next(),
            pmcid: intermediate_rep.pmcid.into_iter().next(),
            core: intermediate_rep.core.into_iter().next(),
            arxiv: intermediate_rep.arxiv.into_iter().next(),
            jstor: intermediate_rep.jstor.into_iter().next(),
            ark: intermediate_rep.ark.into_iter().next(),
            mag: intermediate_rep.mag.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<ReleaseRef> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseRef>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<ReleaseRef>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for ReleaseRef - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseRef> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <ReleaseRef as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into ReleaseRef - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ReleaseRef {
    /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`.
    #[serde(rename = "index")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index: Option<i64>,

    /// Optional, fatcat identifier of release entity that this reference is citing.
    #[serde(rename = "target_release_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target_release_id: Option<String>,

    /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field.
    #[serde(rename = "key")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,

    /// Year that the cited work was published in.
    #[serde(rename = "year")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,

    /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name.
    #[serde(rename = "container_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_name: Option<String>,

    /// Name of the work being cited.
    #[serde(rename = "title")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,

    /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited.
    #[serde(rename = "locator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub locator: Option<String>,
}

impl ReleaseRef {
    pub fn new() -> ReleaseRef {
        ReleaseRef {
            index: None,
            target_release_id: None,
            extra: None,
            key: None,
            year: None,
            container_name: None,
            title: None,
            locator: None,
        }
    }
}

/// Converts the ReleaseRef value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for ReleaseRef {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref index) = self.index {
            params.push("index".to_string());
            params.push(index.to_string());
        }

        if let Some(ref target_release_id) = self.target_release_id {
            params.push("target_release_id".to_string());
            params.push(target_release_id.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        if let Some(ref key) = self.key {
            params.push("key".to_string());
            params.push(key.to_string());
        }

        if let Some(ref year) = self.year {
            params.push("year".to_string());
            params.push(year.to_string());
        }

        if let Some(ref container_name) = self.container_name {
            params.push("container_name".to_string());
            params.push(container_name.to_string());
        }

        if let Some(ref title) = self.title {
            params.push("title".to_string());
            params.push(title.to_string());
        }

        if let Some(ref locator) = self.locator {
            params.push("locator".to_string());
            params.push(locator.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseRef value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for ReleaseRef {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub index: Vec<i64>,
            pub target_release_id: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub key: Vec<String>,
            pub year: Vec<i64>,
            pub container_name: Vec<String>,
            pub title: Vec<String>,
            pub locator: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing ReleaseRef".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "index" => intermediate_rep
                        .index
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "target_release_id" => intermediate_rep
                        .target_release_id
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in ReleaseRef"
                                .to_string(),
                        )
                    }
                    "key" => intermediate_rep
                        .key
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "year" => intermediate_rep
                        .year
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "container_name" => intermediate_rep
                        .container_name
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "title" => intermediate_rep
                        .title
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "locator" => intermediate_rep
                        .locator
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ReleaseRef".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ReleaseRef {
            index: intermediate_rep.index.into_iter().next(),
            target_release_id: intermediate_rep.target_release_id.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            key: intermediate_rep.key.into_iter().next(),
            year: intermediate_rep.year.into_iter().next(),
            container_name: intermediate_rep.container_name.into_iter().next(),
            title: intermediate_rep.title.into_iter().next(),
            locator: intermediate_rep.locator.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<Success> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<Success>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<Success>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for Success - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Success> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <Success as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into Success - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Success {
    #[serde(rename = "success")]
    pub success: bool,

    #[serde(rename = "message")]
    pub message: String,
}

impl Success {
    pub fn new(success: bool, message: String) -> Success {
        Success {
            success: success,
            message: message,
        }
    }
}

/// Converts the Success value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for Success {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("success".to_string());
        params.push(self.success.to_string());

        params.push("message".to_string());
        params.push(self.message.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a Success value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for Success {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub success: Vec<bool>,
            pub message: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing Success".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "success" => intermediate_rep
                        .success
                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
                    "message" => intermediate_rep
                        .message
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Success".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Success {
            success: intermediate_rep
                .success
                .into_iter()
                .next()
                .ok_or("success missing in Success".to_string())?,
            message: intermediate_rep
                .message
                .into_iter()
                .next()
                .ok_or("message missing in Success".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<WebcaptureAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureAutoBatch>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<WebcaptureAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for WebcaptureAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<WebcaptureAutoBatch>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <WebcaptureAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into WebcaptureAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct WebcaptureAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::WebcaptureEntity>,
}

impl WebcaptureAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::WebcaptureEntity>,
    ) -> WebcaptureAutoBatch {
        WebcaptureAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the WebcaptureAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for WebcaptureAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for WebcaptureAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::WebcaptureEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing WebcaptureAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureAutoBatch"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing WebcaptureAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(WebcaptureAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in WebcaptureAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in WebcaptureAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<WebcaptureCdxLine> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureCdxLine>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<WebcaptureCdxLine>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for WebcaptureCdxLine - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<WebcaptureCdxLine>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <WebcaptureCdxLine as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into WebcaptureCdxLine - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct WebcaptureCdxLine {
    /// \"Sortable URL\" format. See guide for details.
    #[serde(rename = "surt")]
    pub surt: String,

    /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision.
    #[serde(rename = "timestamp")]
    pub timestamp: chrono::DateTime<chrono::Utc>,

    /// Full URL/URI of resource captured.
    #[serde(rename = "url")]
    pub url: String,

    /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type.
    #[serde(rename = "mimetype")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mimetype: Option<String>,

    /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully.
    #[serde(rename = "status_code")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_code: Option<i64>,

    /// Resource (file) size in bytes
    #[serde(rename = "size")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,

    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    pub sha1: String,

    /// SHA-256 hash of data, in hex encoding
    #[serde(rename = "sha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,
}

impl WebcaptureCdxLine {
    pub fn new(
        surt: String,
        timestamp: chrono::DateTime<chrono::Utc>,
        url: String,
        sha1: String,
    ) -> WebcaptureCdxLine {
        WebcaptureCdxLine {
            surt: surt,
            timestamp: timestamp,
            url: url,
            mimetype: None,
            status_code: None,
            size: None,
            sha1: sha1,
            sha256: None,
        }
    }
}

/// Converts the WebcaptureCdxLine value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for WebcaptureCdxLine {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("surt".to_string());
        params.push(self.surt.to_string());

        // Skipping timestamp in query parameter serialization

        params.push("url".to_string());
        params.push(self.url.to_string());

        if let Some(ref mimetype) = self.mimetype {
            params.push("mimetype".to_string());
            params.push(mimetype.to_string());
        }

        if let Some(ref status_code) = self.status_code {
            params.push("status_code".to_string());
            params.push(status_code.to_string());
        }

        if let Some(ref size) = self.size {
            params.push("size".to_string());
            params.push(size.to_string());
        }

        params.push("sha1".to_string());
        params.push(self.sha1.to_string());

        if let Some(ref sha256) = self.sha256 {
            params.push("sha256".to_string());
            params.push(sha256.to_string());
        }

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureCdxLine value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for WebcaptureCdxLine {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub surt: Vec<String>,
            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
            pub url: Vec<String>,
            pub mimetype: Vec<String>,
            pub status_code: Vec<i64>,
            pub size: Vec<i64>,
            pub sha1: Vec<String>,
            pub sha256: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing WebcaptureCdxLine".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "surt" => intermediate_rep
                        .surt
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "timestamp" => intermediate_rep.timestamp.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "url" => intermediate_rep
                        .url
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "mimetype" => intermediate_rep
                        .mimetype
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "status_code" => intermediate_rep
                        .status_code
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "size" => intermediate_rep
                        .size
                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
                    "sha1" => intermediate_rep
                        .sha1
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "sha256" => intermediate_rep
                        .sha256
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing WebcaptureCdxLine".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(WebcaptureCdxLine {
            surt: intermediate_rep
                .surt
                .into_iter()
                .next()
                .ok_or("surt missing in WebcaptureCdxLine".to_string())?,
            timestamp: intermediate_rep
                .timestamp
                .into_iter()
                .next()
                .ok_or("timestamp missing in WebcaptureCdxLine".to_string())?,
            url: intermediate_rep
                .url
                .into_iter()
                .next()
                .ok_or("url missing in WebcaptureCdxLine".to_string())?,
            mimetype: intermediate_rep.mimetype.into_iter().next(),
            status_code: intermediate_rep.status_code.into_iter().next(),
            size: intermediate_rep.size.into_iter().next(),
            sha1: intermediate_rep
                .sha1
                .into_iter()
                .next()
                .ok_or("sha1 missing in WebcaptureCdxLine".to_string())?,
            sha256: intermediate_rep.sha256.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<WebcaptureEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureEntity>>
    for hyper::header::HeaderValue
{
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<WebcaptureEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for WebcaptureEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<WebcaptureEntity>
{
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <WebcaptureEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into WebcaptureEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct WebcaptureEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    #[serde(rename = "cdx")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cdx: Option<Vec<models::WebcaptureCdxLine>>,

    #[serde(rename = "archive_urls")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archive_urls: Option<Vec<models::WebcaptureUrl>>,

    /// Base URL of the primary resource this is a capture of
    #[serde(rename = "original_url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub original_url: Option<String>,

    /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL.
    #[serde(rename = "timestamp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,

    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
    #[serde(rename = "release_ids")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_ids: Option<Vec<String>>,

    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::ReleaseEntity>>,
}

impl WebcaptureEntity {
    pub fn new() -> WebcaptureEntity {
        WebcaptureEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
            cdx: None,
            archive_urls: None,
            original_url: None,
            timestamp: None,
            release_ids: None,
            releases: None,
        }
    }
}

/// Converts the WebcaptureEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for WebcaptureEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        // Skipping cdx in query parameter serialization

        // Skipping archive_urls in query parameter serialization

        if let Some(ref original_url) = self.original_url {
            params.push("original_url".to_string());
            params.push(original_url.to_string());
        }

        // Skipping timestamp in query parameter serialization

        if let Some(ref release_ids) = self.release_ids {
            params.push("release_ids".to_string());
            params.push(
                release_ids
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(",")
                    .to_string(),
            );
        }

        // Skipping releases in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for WebcaptureEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub cdx: Vec<Vec<models::WebcaptureCdxLine>>,
            pub archive_urls: Vec<Vec<models::WebcaptureUrl>>,
            pub original_url: Vec<String>,
            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
            pub release_ids: Vec<Vec<String>>,
            pub releases: Vec<Vec<models::ReleaseEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing WebcaptureEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureEntity"
                            .to_string(),
                    ),
                    "edit_extra" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureEntity"
                            .to_string(),
                    ),
                    "cdx" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureEntity"
                            .to_string(),
                    ),
                    "archive_urls" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureEntity"
                            .to_string(),
                    ),
                    "original_url" => intermediate_rep
                        .original_url
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "timestamp" => intermediate_rep.timestamp.push(
                        chrono::DateTime::<chrono::Utc>::from_str(val)
                            .map_err(|x| format!("{}", x))?,
                    ),
                    "release_ids" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureEntity"
                            .to_string(),
                    ),
                    "releases" => return std::result::Result::Err(
                        "Parsing a container in this style is not supported in WebcaptureEntity"
                            .to_string(),
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing WebcaptureEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(WebcaptureEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
            cdx: intermediate_rep.cdx.into_iter().next(),
            archive_urls: intermediate_rep.archive_urls.into_iter().next(),
            original_url: intermediate_rep.original_url.into_iter().next(),
            timestamp: intermediate_rep.timestamp.into_iter().next(),
            release_ids: intermediate_rep.release_ids.into_iter().next(),
            releases: intermediate_rep.releases.into_iter().next(),
        })
    }
}

// Methods for converting between header::IntoHeaderValue<WebcaptureUrl> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureUrl>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<WebcaptureUrl>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for WebcaptureUrl - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WebcaptureUrl> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <WebcaptureUrl as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into WebcaptureUrl - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct WebcaptureUrl {
    /// URL/URI pointing to archive of this web resource.
    #[serde(rename = "url")]
    pub url: String,

    /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list.
    #[serde(rename = "rel")]
    pub rel: String,
}

impl WebcaptureUrl {
    pub fn new(url: String, rel: String) -> WebcaptureUrl {
        WebcaptureUrl { url: url, rel: rel }
    }
}

/// Converts the WebcaptureUrl value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for WebcaptureUrl {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        params.push("url".to_string());
        params.push(self.url.to_string());

        params.push("rel".to_string());
        params.push(self.rel.to_string());

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureUrl value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for WebcaptureUrl {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub url: Vec<String>,
            pub rel: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing WebcaptureUrl".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "url" => intermediate_rep
                        .url
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "rel" => intermediate_rep
                        .rel
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing WebcaptureUrl".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(WebcaptureUrl {
            url: intermediate_rep
                .url
                .into_iter()
                .next()
                .ok_or("url missing in WebcaptureUrl".to_string())?,
            rel: intermediate_rep
                .rel
                .into_iter()
                .next()
                .ok_or("rel missing in WebcaptureUrl".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<WorkAutoBatch> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<WorkAutoBatch>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<WorkAutoBatch>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for WorkAutoBatch - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkAutoBatch> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <WorkAutoBatch as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into WorkAutoBatch - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct WorkAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::WorkEntity>,
}

impl WorkAutoBatch {
    pub fn new(
        editgroup: models::Editgroup,
        entity_list: Vec<models::WorkEntity>,
    ) -> WorkAutoBatch {
        WorkAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

/// Converts the WorkAutoBatch value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for WorkAutoBatch {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];
        // Skipping editgroup in query parameter serialization

        // Skipping entity_list in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a WorkAutoBatch value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for WorkAutoBatch {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub editgroup: Vec<models::Editgroup>,
            pub entity_list: Vec<Vec<models::WorkEntity>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing WorkAutoBatch".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "editgroup" => intermediate_rep
                        .editgroup
                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
                    "entity_list" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in WorkAutoBatch"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing WorkAutoBatch".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(WorkAutoBatch {
            editgroup: intermediate_rep
                .editgroup
                .into_iter()
                .next()
                .ok_or("editgroup missing in WorkAutoBatch".to_string())?,
            entity_list: intermediate_rep
                .entity_list
                .into_iter()
                .next()
                .ok_or("entity_list missing in WorkAutoBatch".to_string())?,
        })
    }
}

// Methods for converting between header::IntoHeaderValue<WorkEntity> and hyper::header::HeaderValue

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<header::IntoHeaderValue<WorkEntity>> for hyper::header::HeaderValue {
    type Error = String;

    fn try_from(
        hdr_value: header::IntoHeaderValue<WorkEntity>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_value = hdr_value.to_string();
        match hyper::header::HeaderValue::from_str(&hdr_value) {
            std::result::Result::Ok(value) => std::result::Result::Ok(value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Invalid header value for WorkEntity - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkEntity> {
    type Error = String;

    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_value.to_str() {
            std::result::Result::Ok(value) => {
                match <WorkEntity as std::str::FromStr>::from_str(value) {
                    std::result::Result::Ok(value) => {
                        std::result::Result::Ok(header::IntoHeaderValue(value))
                    }
                    std::result::Result::Err(err) => std::result::Result::Err(format!(
                        "Unable to convert header value '{}' into WorkEntity - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct WorkEntity {
    // Note: inline enums are not fully supported by openapi-generator
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
}

impl WorkEntity {
    pub fn new() -> WorkEntity {
        WorkEntity {
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
        }
    }
}

/// Converts the WorkEntity value to the Query Parameters representation (style=form, explode=false)
/// specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde serializer
impl std::string::ToString for WorkEntity {
    fn to_string(&self) -> String {
        let mut params: Vec<String> = vec![];

        if let Some(ref state) = self.state {
            params.push("state".to_string());
            params.push(state.to_string());
        }

        if let Some(ref ident) = self.ident {
            params.push("ident".to_string());
            params.push(ident.to_string());
        }

        if let Some(ref revision) = self.revision {
            params.push("revision".to_string());
            params.push(revision.to_string());
        }

        if let Some(ref redirect) = self.redirect {
            params.push("redirect".to_string());
            params.push(redirect.to_string());
        }

        // Skipping extra in query parameter serialization
        // Skipping extra in query parameter serialization

        // Skipping edit_extra in query parameter serialization
        // Skipping edit_extra in query parameter serialization

        params.join(",").to_string()
    }
}

/// Converts Query Parameters representation (style=form, explode=false) to a WorkEntity value
/// as specified in https://swagger.io/docs/specification/serialization/
/// Should be implemented in a serde deserializer
impl std::str::FromStr for WorkEntity {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        #[derive(Default)]
        // An intermediate representation of the struct to use for parsing.
        struct IntermediateRep {
            pub state: Vec<String>,
            pub ident: Vec<String>,
            pub revision: Vec<String>,
            pub redirect: Vec<String>,
            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',').into_iter();
        let mut key_result = string_iter.next();

        while key_result.is_some() {
            let val = match string_iter.next() {
                Some(x) => x,
                None => {
                    return std::result::Result::Err(
                        "Missing value while parsing WorkEntity".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                match key {
                    "state" => intermediate_rep
                        .state
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "ident" => intermediate_rep
                        .ident
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "revision" => intermediate_rep
                        .revision
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "redirect" => intermediate_rep
                        .redirect
                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
                    "extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in WorkEntity"
                                .to_string(),
                        )
                    }
                    "edit_extra" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in WorkEntity"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing WorkEntity".to_string(),
                        )
                    }
                }
            }

            // Get the next key
            key_result = string_iter.next();
        }

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(WorkEntity {
            state: intermediate_rep.state.into_iter().next(),
            ident: intermediate_rep.ident.into_iter().next(),
            revision: intermediate_rep.revision.into_iter().next(),
            redirect: intermediate_rep.redirect.into_iter().next(),
            extra: intermediate_rep.extra.into_iter().next(),
            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
        })
    }
}