move source code to top-level directory

1 files changed, 0 insertions, 7621 deletions

diff --git a/rust/fatcat-openapi/src/models.rs b/rust/fatcat-openapi/src/models.rs
deleted file mode 100644
index d642c62..0000000
--- a/rust/fatcat-openapi/src/models.rs
+++ /dev/null
@@ -1,7621 +0,0 @@
-#![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::NaiveDate>,
-
-    /// 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::NaiveDate>,
-
-    /// 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::NaiveDate>,
-            pub release_year: Vec<i64>,
-            pub withdrawn_status: Vec<String>,
-            pub withdrawn_date: Vec<chrono::NaiveDate>,
-            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::NaiveDate::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::NaiveDate::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>,
-
-    /// DOAJ article-level identifier
-    #[serde(rename = "doaj")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub doaj: Option<String>,
-
-    /// dblp (https://dblp.uni-trier.de/) paper identifier; eg for conference proceedings
-    #[serde(rename = "dblp")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub dblp: Option<String>,
-
-    /// OAI-PMH identifier; only used when an OAI-PMH record is the only authoritative metadata (eg, journal OAI-PMH feeds w/o DOIs)
-    #[serde(rename = "oai")]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub oai: 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,
-            doaj: None,
-            dblp: None,
-            oai: 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());
-        }
-
-        if let Some(ref doaj) = self.doaj {
-            params.push("doaj".to_string());
-            params.push(doaj.to_string());
-        }
-
-        if let Some(ref dblp) = self.dblp {
-            params.push("dblp".to_string());
-            params.push(dblp.to_string());
-        }
-
-        if let Some(ref oai) = self.oai {
-            params.push("oai".to_string());
-            params.push(oai.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>,
-            pub doaj: Vec<String>,
-            pub dblp: Vec<String>,
-            pub oai: 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))?),
-                    "doaj" => intermediate_rep
-                        .doaj
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "dblp" => intermediate_rep
-                        .dblp
-                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
-                    "oai" => intermediate_rep
-                        .oai
-                        .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(),
-            doaj: intermediate_rep.doaj.into_iter().next(),
-            dblp: intermediate_rep.dblp.into_iter().next(),
-            oai: intermediate_rep.oai.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(),
-        })
-    }
-}