copy codegen rust openapi client from fatcat repo

1 files changed, 7573 insertions, 0 deletions

diff --git a/rust/fatcat-openapi/src/models.rs b/rust/fatcat-openapi/src/models.rs
new file mode 100644
index 0000000..b0a802c
--- /dev/null
+++ b/rust/fatcat-openapi/src/models.rs
@@ -0,0 +1,7573 @@
+#![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>,
+}
+
+impl ReleaseExtIds {
+    pub fn new() -> ReleaseExtIds {
+        ReleaseExtIds {
+            doi: None,
+            wikidata_qid: None,
+            isbn13: None,
+            pmid: None,
+            pmcid: None,
+            core: None,
+            arxiv: None,
+            jstor: None,
+            ark: None,
+            mag: None,
+        }
+    }
+}
+
+/// Converts the ReleaseExtIds value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseExtIds {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref doi) = self.doi {
+            params.push("doi".to_string());
+            params.push(doi.to_string());
+        }
+
+        if let Some(ref wikidata_qid) = self.wikidata_qid {
+            params.push("wikidata_qid".to_string());
+            params.push(wikidata_qid.to_string());
+        }
+
+        if let Some(ref isbn13) = self.isbn13 {
+            params.push("isbn13".to_string());
+            params.push(isbn13.to_string());
+        }
+
+        if let Some(ref pmid) = self.pmid {
+            params.push("pmid".to_string());
+            params.push(pmid.to_string());
+        }
+
+        if let Some(ref pmcid) = self.pmcid {
+            params.push("pmcid".to_string());
+            params.push(pmcid.to_string());
+        }
+
+        if let Some(ref core) = self.core {
+            params.push("core".to_string());
+            params.push(core.to_string());
+        }
+
+        if let Some(ref arxiv) = self.arxiv {
+            params.push("arxiv".to_string());
+            params.push(arxiv.to_string());
+        }
+
+        if let Some(ref jstor) = self.jstor {
+            params.push("jstor".to_string());
+            params.push(jstor.to_string());
+        }
+
+        if let Some(ref ark) = self.ark {
+            params.push("ark".to_string());
+            params.push(ark.to_string());
+        }
+
+        if let Some(ref mag) = self.mag {
+            params.push("mag".to_string());
+            params.push(mag.to_string());
+        }
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseExtIds value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseExtIds {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub doi: Vec<String>,
+            pub wikidata_qid: Vec<String>,
+            pub isbn13: Vec<String>,
+            pub pmid: Vec<String>,
+            pub pmcid: Vec<String>,
+            pub core: Vec<String>,
+            pub arxiv: Vec<String>,
+            pub jstor: Vec<String>,
+            pub ark: Vec<String>,
+            pub mag: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing ReleaseExtIds".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "doi" => intermediate_rep
+                        .doi
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "wikidata_qid" => intermediate_rep
+                        .wikidata_qid
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "isbn13" => intermediate_rep
+                        .isbn13
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "pmid" => intermediate_rep
+                        .pmid
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "pmcid" => intermediate_rep
+                        .pmcid
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "core" => intermediate_rep
+                        .core
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "arxiv" => intermediate_rep
+                        .arxiv
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "jstor" => intermediate_rep
+                        .jstor
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "ark" => intermediate_rep
+                        .ark
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "mag" => intermediate_rep
+                        .mag
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing ReleaseExtIds".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(ReleaseExtIds {
+            doi: intermediate_rep.doi.into_iter().next(),
+            wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
+            isbn13: intermediate_rep.isbn13.into_iter().next(),
+            pmid: intermediate_rep.pmid.into_iter().next(),
+            pmcid: intermediate_rep.pmcid.into_iter().next(),
+            core: intermediate_rep.core.into_iter().next(),
+            arxiv: intermediate_rep.arxiv.into_iter().next(),
+            jstor: intermediate_rep.jstor.into_iter().next(),
+            ark: intermediate_rep.ark.into_iter().next(),
+            mag: intermediate_rep.mag.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseRef> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseRef>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<ReleaseRef>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for ReleaseRef - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseRef> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <ReleaseRef as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into ReleaseRef - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseRef {
+    /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`.
+    #[serde(rename = "index")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub index: Option<i64>,
+
+    /// Optional, fatcat identifier of release entity that this reference is citing.
+    #[serde(rename = "target_release_id")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target_release_id: Option<String>,
+
+    /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details.
+    #[serde(rename = "extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field.
+    #[serde(rename = "key")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+
+    /// Year that the cited work was published in.
+    #[serde(rename = "year")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub year: Option<i64>,
+
+    /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name.
+    #[serde(rename = "container_name")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub container_name: Option<String>,
+
+    /// Name of the work being cited.
+    #[serde(rename = "title")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+
+    /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited.
+    #[serde(rename = "locator")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub locator: Option<String>,
+}
+
+impl ReleaseRef {
+    pub fn new() -> ReleaseRef {
+        ReleaseRef {
+            index: None,
+            target_release_id: None,
+            extra: None,
+            key: None,
+            year: None,
+            container_name: None,
+            title: None,
+            locator: None,
+        }
+    }
+}
+
+/// Converts the ReleaseRef value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseRef {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref index) = self.index {
+            params.push("index".to_string());
+            params.push(index.to_string());
+        }
+
+        if let Some(ref target_release_id) = self.target_release_id {
+            params.push("target_release_id".to_string());
+            params.push(target_release_id.to_string());
+        }
+
+        // Skipping extra in query parameter serialization
+        // Skipping extra in query parameter serialization
+
+        if let Some(ref key) = self.key {
+            params.push("key".to_string());
+            params.push(key.to_string());
+        }
+
+        if let Some(ref year) = self.year {
+            params.push("year".to_string());
+            params.push(year.to_string());
+        }
+
+        if let Some(ref container_name) = self.container_name {
+            params.push("container_name".to_string());
+            params.push(container_name.to_string());
+        }
+
+        if let Some(ref title) = self.title {
+            params.push("title".to_string());
+            params.push(title.to_string());
+        }
+
+        if let Some(ref locator) = self.locator {
+            params.push("locator".to_string());
+            params.push(locator.to_string());
+        }
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseRef value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseRef {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub index: Vec<i64>,
+            pub target_release_id: Vec<String>,
+            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub key: Vec<String>,
+            pub year: Vec<i64>,
+            pub container_name: Vec<String>,
+            pub title: Vec<String>,
+            pub locator: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing ReleaseRef".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "index" => intermediate_rep
+                        .index
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "target_release_id" => intermediate_rep
+                        .target_release_id
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "extra" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in ReleaseRef"
+                                .to_string(),
+                        )
+                    }
+                    "key" => intermediate_rep
+                        .key
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "year" => intermediate_rep
+                        .year
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "container_name" => intermediate_rep
+                        .container_name
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "title" => intermediate_rep
+                        .title
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "locator" => intermediate_rep
+                        .locator
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing ReleaseRef".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(ReleaseRef {
+            index: intermediate_rep.index.into_iter().next(),
+            target_release_id: intermediate_rep.target_release_id.into_iter().next(),
+            extra: intermediate_rep.extra.into_iter().next(),
+            key: intermediate_rep.key.into_iter().next(),
+            year: intermediate_rep.year.into_iter().next(),
+            container_name: intermediate_rep.container_name.into_iter().next(),
+            title: intermediate_rep.title.into_iter().next(),
+            locator: intermediate_rep.locator.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<Success> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<Success>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<Success>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for Success - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Success> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <Success as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into Success - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct Success {
+    #[serde(rename = "success")]
+    pub success: bool,
+
+    #[serde(rename = "message")]
+    pub message: String,
+}
+
+impl Success {
+    pub fn new(success: bool, message: String) -> Success {
+        Success {
+            success: success,
+            message: message,
+        }
+    }
+}
+
+/// Converts the Success value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for Success {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        params.push("success".to_string());
+        params.push(self.success.to_string());
+
+        params.push("message".to_string());
+        params.push(self.message.to_string());
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a Success value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for Success {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub success: Vec<bool>,
+            pub message: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing Success".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "success" => intermediate_rep
+                        .success
+                        .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+                    "message" => intermediate_rep
+                        .message
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing Success".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(Success {
+            success: intermediate_rep
+                .success
+                .into_iter()
+                .next()
+                .ok_or("success missing in Success".to_string())?,
+            message: intermediate_rep
+                .message
+                .into_iter()
+                .next()
+                .ok_or("message missing in Success".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureAutoBatch>>
+    for hyper::header::HeaderValue
+{
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureAutoBatch>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureAutoBatch - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+    for header::IntoHeaderValue<WebcaptureAutoBatch>
+{
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureAutoBatch as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureAutoBatch - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureAutoBatch {
+    #[serde(rename = "editgroup")]
+    pub editgroup: models::Editgroup,
+
+    #[serde(rename = "entity_list")]
+    pub entity_list: Vec<models::WebcaptureEntity>,
+}
+
+impl WebcaptureAutoBatch {
+    pub fn new(
+        editgroup: models::Editgroup,
+        entity_list: Vec<models::WebcaptureEntity>,
+    ) -> WebcaptureAutoBatch {
+        WebcaptureAutoBatch {
+            editgroup: editgroup,
+            entity_list: entity_list,
+        }
+    }
+}
+
+/// Converts the WebcaptureAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureAutoBatch {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+        // Skipping editgroup in query parameter serialization
+
+        // Skipping entity_list in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureAutoBatch {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub editgroup: Vec<models::Editgroup>,
+            pub entity_list: Vec<Vec<models::WebcaptureEntity>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureAutoBatch".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "editgroup" => intermediate_rep
+                        .editgroup
+                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+                    "entity_list" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureAutoBatch"
+                            .to_string(),
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureAutoBatch".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureAutoBatch {
+            editgroup: intermediate_rep
+                .editgroup
+                .into_iter()
+                .next()
+                .ok_or("editgroup missing in WebcaptureAutoBatch".to_string())?,
+            entity_list: intermediate_rep
+                .entity_list
+                .into_iter()
+                .next()
+                .ok_or("entity_list missing in WebcaptureAutoBatch".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureCdxLine> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureCdxLine>>
+    for hyper::header::HeaderValue
+{
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureCdxLine>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureCdxLine - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+    for header::IntoHeaderValue<WebcaptureCdxLine>
+{
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureCdxLine as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureCdxLine - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureCdxLine {
+    /// \"Sortable URL\" format. See guide for details.
+    #[serde(rename = "surt")]
+    pub surt: String,
+
+    /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision.
+    #[serde(rename = "timestamp")]
+    pub timestamp: chrono::DateTime<chrono::Utc>,
+
+    /// Full URL/URI of resource captured.
+    #[serde(rename = "url")]
+    pub url: String,
+
+    /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type.
+    #[serde(rename = "mimetype")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mimetype: Option<String>,
+
+    /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully.
+    #[serde(rename = "status_code")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub status_code: Option<i64>,
+
+    /// Resource (file) size in bytes
+    #[serde(rename = "size")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub size: Option<i64>,
+
+    /// SHA-1 hash of data, in hex encoding
+    #[serde(rename = "sha1")]
+    pub sha1: String,
+
+    /// SHA-256 hash of data, in hex encoding
+    #[serde(rename = "sha256")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sha256: Option<String>,
+}
+
+impl WebcaptureCdxLine {
+    pub fn new(
+        surt: String,
+        timestamp: chrono::DateTime<chrono::Utc>,
+        url: String,
+        sha1: String,
+    ) -> WebcaptureCdxLine {
+        WebcaptureCdxLine {
+            surt: surt,
+            timestamp: timestamp,
+            url: url,
+            mimetype: None,
+            status_code: None,
+            size: None,
+            sha1: sha1,
+            sha256: None,
+        }
+    }
+}
+
+/// Converts the WebcaptureCdxLine value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureCdxLine {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        params.push("surt".to_string());
+        params.push(self.surt.to_string());
+
+        // Skipping timestamp in query parameter serialization
+
+        params.push("url".to_string());
+        params.push(self.url.to_string());
+
+        if let Some(ref mimetype) = self.mimetype {
+            params.push("mimetype".to_string());
+            params.push(mimetype.to_string());
+        }
+
+        if let Some(ref status_code) = self.status_code {
+            params.push("status_code".to_string());
+            params.push(status_code.to_string());
+        }
+
+        if let Some(ref size) = self.size {
+            params.push("size".to_string());
+            params.push(size.to_string());
+        }
+
+        params.push("sha1".to_string());
+        params.push(self.sha1.to_string());
+
+        if let Some(ref sha256) = self.sha256 {
+            params.push("sha256".to_string());
+            params.push(sha256.to_string());
+        }
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureCdxLine value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureCdxLine {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub surt: Vec<String>,
+            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+            pub url: Vec<String>,
+            pub mimetype: Vec<String>,
+            pub status_code: Vec<i64>,
+            pub size: Vec<i64>,
+            pub sha1: Vec<String>,
+            pub sha256: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureCdxLine".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "surt" => intermediate_rep
+                        .surt
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "timestamp" => intermediate_rep.timestamp.push(
+                        chrono::DateTime::<chrono::Utc>::from_str(val)
+                            .map_err(|x| format!("{}", x))?,
+                    ),
+                    "url" => intermediate_rep
+                        .url
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "mimetype" => intermediate_rep
+                        .mimetype
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "status_code" => intermediate_rep
+                        .status_code
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "size" => intermediate_rep
+                        .size
+                        .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+                    "sha1" => intermediate_rep
+                        .sha1
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "sha256" => intermediate_rep
+                        .sha256
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureCdxLine".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureCdxLine {
+            surt: intermediate_rep
+                .surt
+                .into_iter()
+                .next()
+                .ok_or("surt missing in WebcaptureCdxLine".to_string())?,
+            timestamp: intermediate_rep
+                .timestamp
+                .into_iter()
+                .next()
+                .ok_or("timestamp missing in WebcaptureCdxLine".to_string())?,
+            url: intermediate_rep
+                .url
+                .into_iter()
+                .next()
+                .ok_or("url missing in WebcaptureCdxLine".to_string())?,
+            mimetype: intermediate_rep.mimetype.into_iter().next(),
+            status_code: intermediate_rep.status_code.into_iter().next(),
+            size: intermediate_rep.size.into_iter().next(),
+            sha1: intermediate_rep
+                .sha1
+                .into_iter()
+                .next()
+                .ok_or("sha1 missing in WebcaptureCdxLine".to_string())?,
+            sha256: intermediate_rep.sha256.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureEntity>>
+    for hyper::header::HeaderValue
+{
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureEntity>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureEntity - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+    for header::IntoHeaderValue<WebcaptureEntity>
+{
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureEntity as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureEntity - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureEntity {
+    // Note: inline enums are not fully supported by openapi-generator
+    #[serde(rename = "state")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "ident")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ident: Option<String>,
+
+    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+    #[serde(rename = "revision")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub revision: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "redirect")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub redirect: Option<String>,
+
+    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+    #[serde(rename = "extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+    #[serde(rename = "edit_extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    #[serde(rename = "cdx")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cdx: Option<Vec<models::WebcaptureCdxLine>>,
+
+    #[serde(rename = "archive_urls")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub archive_urls: Option<Vec<models::WebcaptureUrl>>,
+
+    /// Base URL of the primary resource this is a capture of
+    #[serde(rename = "original_url")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub original_url: Option<String>,
+
+    /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL.
+    #[serde(rename = "timestamp")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
+
+    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
+    #[serde(rename = "release_ids")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub release_ids: Option<Vec<String>>,
+
+    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
+    #[serde(rename = "releases")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub releases: Option<Vec<models::ReleaseEntity>>,
+}
+
+impl WebcaptureEntity {
+    pub fn new() -> WebcaptureEntity {
+        WebcaptureEntity {
+            state: None,
+            ident: None,
+            revision: None,
+            redirect: None,
+            extra: None,
+            edit_extra: None,
+            cdx: None,
+            archive_urls: None,
+            original_url: None,
+            timestamp: None,
+            release_ids: None,
+            releases: None,
+        }
+    }
+}
+
+/// Converts the WebcaptureEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureEntity {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref state) = self.state {
+            params.push("state".to_string());
+            params.push(state.to_string());
+        }
+
+        if let Some(ref ident) = self.ident {
+            params.push("ident".to_string());
+            params.push(ident.to_string());
+        }
+
+        if let Some(ref revision) = self.revision {
+            params.push("revision".to_string());
+            params.push(revision.to_string());
+        }
+
+        if let Some(ref redirect) = self.redirect {
+            params.push("redirect".to_string());
+            params.push(redirect.to_string());
+        }
+
+        // Skipping extra in query parameter serialization
+        // Skipping extra in query parameter serialization
+
+        // Skipping edit_extra in query parameter serialization
+        // Skipping edit_extra in query parameter serialization
+
+        // Skipping cdx in query parameter serialization
+
+        // Skipping archive_urls in query parameter serialization
+
+        if let Some(ref original_url) = self.original_url {
+            params.push("original_url".to_string());
+            params.push(original_url.to_string());
+        }
+
+        // Skipping timestamp in query parameter serialization
+
+        if let Some(ref release_ids) = self.release_ids {
+            params.push("release_ids".to_string());
+            params.push(
+                release_ids
+                    .iter()
+                    .map(|x| x.to_string())
+                    .collect::<Vec<_>>()
+                    .join(",")
+                    .to_string(),
+            );
+        }
+
+        // Skipping releases in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureEntity {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub state: Vec<String>,
+            pub ident: Vec<String>,
+            pub revision: Vec<String>,
+            pub redirect: Vec<String>,
+            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub cdx: Vec<Vec<models::WebcaptureCdxLine>>,
+            pub archive_urls: Vec<Vec<models::WebcaptureUrl>>,
+            pub original_url: Vec<String>,
+            pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+            pub release_ids: Vec<Vec<String>>,
+            pub releases: Vec<Vec<models::ReleaseEntity>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureEntity".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "state" => intermediate_rep
+                        .state
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "ident" => intermediate_rep
+                        .ident
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "revision" => intermediate_rep
+                        .revision
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "redirect" => intermediate_rep
+                        .redirect
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "extra" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "edit_extra" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "cdx" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "archive_urls" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "original_url" => intermediate_rep
+                        .original_url
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "timestamp" => intermediate_rep.timestamp.push(
+                        chrono::DateTime::<chrono::Utc>::from_str(val)
+                            .map_err(|x| format!("{}", x))?,
+                    ),
+                    "release_ids" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    "releases" => return std::result::Result::Err(
+                        "Parsing a container in this style is not supported in WebcaptureEntity"
+                            .to_string(),
+                    ),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureEntity".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureEntity {
+            state: intermediate_rep.state.into_iter().next(),
+            ident: intermediate_rep.ident.into_iter().next(),
+            revision: intermediate_rep.revision.into_iter().next(),
+            redirect: intermediate_rep.redirect.into_iter().next(),
+            extra: intermediate_rep.extra.into_iter().next(),
+            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+            cdx: intermediate_rep.cdx.into_iter().next(),
+            archive_urls: intermediate_rep.archive_urls.into_iter().next(),
+            original_url: intermediate_rep.original_url.into_iter().next(),
+            timestamp: intermediate_rep.timestamp.into_iter().next(),
+            release_ids: intermediate_rep.release_ids.into_iter().next(),
+            releases: intermediate_rep.releases.into_iter().next(),
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureUrl> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureUrl>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WebcaptureUrl>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WebcaptureUrl - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WebcaptureUrl> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WebcaptureUrl as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WebcaptureUrl - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureUrl {
+    /// URL/URI pointing to archive of this web resource.
+    #[serde(rename = "url")]
+    pub url: String,
+
+    /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list.
+    #[serde(rename = "rel")]
+    pub rel: String,
+}
+
+impl WebcaptureUrl {
+    pub fn new(url: String, rel: String) -> WebcaptureUrl {
+        WebcaptureUrl { url: url, rel: rel }
+    }
+}
+
+/// Converts the WebcaptureUrl value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureUrl {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        params.push("url".to_string());
+        params.push(self.url.to_string());
+
+        params.push("rel".to_string());
+        params.push(self.rel.to_string());
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureUrl value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureUrl {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub url: Vec<String>,
+            pub rel: Vec<String>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WebcaptureUrl".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "url" => intermediate_rep
+                        .url
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "rel" => intermediate_rep
+                        .rel
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WebcaptureUrl".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WebcaptureUrl {
+            url: intermediate_rep
+                .url
+                .into_iter()
+                .next()
+                .ok_or("url missing in WebcaptureUrl".to_string())?,
+            rel: intermediate_rep
+                .rel
+                .into_iter()
+                .next()
+                .ok_or("rel missing in WebcaptureUrl".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WorkAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WorkAutoBatch>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WorkAutoBatch>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WorkAutoBatch - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkAutoBatch> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WorkAutoBatch as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WorkAutoBatch - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WorkAutoBatch {
+    #[serde(rename = "editgroup")]
+    pub editgroup: models::Editgroup,
+
+    #[serde(rename = "entity_list")]
+    pub entity_list: Vec<models::WorkEntity>,
+}
+
+impl WorkAutoBatch {
+    pub fn new(
+        editgroup: models::Editgroup,
+        entity_list: Vec<models::WorkEntity>,
+    ) -> WorkAutoBatch {
+        WorkAutoBatch {
+            editgroup: editgroup,
+            entity_list: entity_list,
+        }
+    }
+}
+
+/// Converts the WorkAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WorkAutoBatch {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+        // Skipping editgroup in query parameter serialization
+
+        // Skipping entity_list in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WorkAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WorkAutoBatch {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub editgroup: Vec<models::Editgroup>,
+            pub entity_list: Vec<Vec<models::WorkEntity>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WorkAutoBatch".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "editgroup" => intermediate_rep
+                        .editgroup
+                        .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+                    "entity_list" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in WorkAutoBatch"
+                                .to_string(),
+                        )
+                    }
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WorkAutoBatch".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WorkAutoBatch {
+            editgroup: intermediate_rep
+                .editgroup
+                .into_iter()
+                .next()
+                .ok_or("editgroup missing in WorkAutoBatch".to_string())?,
+            entity_list: intermediate_rep
+                .entity_list
+                .into_iter()
+                .next()
+                .ok_or("entity_list missing in WorkAutoBatch".to_string())?,
+        })
+    }
+}
+
+// Methods for converting between header::IntoHeaderValue<WorkEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WorkEntity>> for hyper::header::HeaderValue {
+    type Error = String;
+
+    fn try_from(
+        hdr_value: header::IntoHeaderValue<WorkEntity>,
+    ) -> std::result::Result<Self, Self::Error> {
+        let hdr_value = hdr_value.to_string();
+        match hyper::header::HeaderValue::from_str(&hdr_value) {
+            std::result::Result::Ok(value) => std::result::Result::Ok(value),
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Invalid header value for WorkEntity - value: {} is invalid {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkEntity> {
+    type Error = String;
+
+    fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+        match hdr_value.to_str() {
+            std::result::Result::Ok(value) => {
+                match <WorkEntity as std::str::FromStr>::from_str(value) {
+                    std::result::Result::Ok(value) => {
+                        std::result::Result::Ok(header::IntoHeaderValue(value))
+                    }
+                    std::result::Result::Err(err) => std::result::Result::Err(format!(
+                        "Unable to convert header value '{}' into WorkEntity - {}",
+                        value, err
+                    )),
+                }
+            }
+            std::result::Result::Err(e) => std::result::Result::Err(format!(
+                "Unable to convert header: {:?} to string: {}",
+                hdr_value, e
+            )),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WorkEntity {
+    // Note: inline enums are not fully supported by openapi-generator
+    #[serde(rename = "state")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub state: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "ident")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ident: Option<String>,
+
+    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+    #[serde(rename = "revision")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub revision: Option<String>,
+
+    /// base32-encoded unique identifier
+    #[serde(rename = "redirect")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub redirect: Option<String>,
+
+    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+    #[serde(rename = "extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+    #[serde(rename = "edit_extra")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl WorkEntity {
+    pub fn new() -> WorkEntity {
+        WorkEntity {
+            state: None,
+            ident: None,
+            revision: None,
+            redirect: None,
+            extra: None,
+            edit_extra: None,
+        }
+    }
+}
+
+/// Converts the WorkEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WorkEntity {
+    fn to_string(&self) -> String {
+        let mut params: Vec<String> = vec![];
+
+        if let Some(ref state) = self.state {
+            params.push("state".to_string());
+            params.push(state.to_string());
+        }
+
+        if let Some(ref ident) = self.ident {
+            params.push("ident".to_string());
+            params.push(ident.to_string());
+        }
+
+        if let Some(ref revision) = self.revision {
+            params.push("revision".to_string());
+            params.push(revision.to_string());
+        }
+
+        if let Some(ref redirect) = self.redirect {
+            params.push("redirect".to_string());
+            params.push(redirect.to_string());
+        }
+
+        // Skipping extra in query parameter serialization
+        // Skipping extra in query parameter serialization
+
+        // Skipping edit_extra in query parameter serialization
+        // Skipping edit_extra in query parameter serialization
+
+        params.join(",").to_string()
+    }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WorkEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WorkEntity {
+    type Err = String;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        #[derive(Default)]
+        // An intermediate representation of the struct to use for parsing.
+        struct IntermediateRep {
+            pub state: Vec<String>,
+            pub ident: Vec<String>,
+            pub revision: Vec<String>,
+            pub redirect: Vec<String>,
+            pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+            pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+        }
+
+        let mut intermediate_rep = IntermediateRep::default();
+
+        // Parse into intermediate representation
+        let mut string_iter = s.split(',').into_iter();
+        let mut key_result = string_iter.next();
+
+        while key_result.is_some() {
+            let val = match string_iter.next() {
+                Some(x) => x,
+                None => {
+                    return std::result::Result::Err(
+                        "Missing value while parsing WorkEntity".to_string(),
+                    )
+                }
+            };
+
+            if let Some(key) = key_result {
+                match key {
+                    "state" => intermediate_rep
+                        .state
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "ident" => intermediate_rep
+                        .ident
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "revision" => intermediate_rep
+                        .revision
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "redirect" => intermediate_rep
+                        .redirect
+                        .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+                    "extra" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in WorkEntity"
+                                .to_string(),
+                        )
+                    }
+                    "edit_extra" => {
+                        return std::result::Result::Err(
+                            "Parsing a container in this style is not supported in WorkEntity"
+                                .to_string(),
+                        )
+                    }
+                    _ => {
+                        return std::result::Result::Err(
+                            "Unexpected key while parsing WorkEntity".to_string(),
+                        )
+                    }
+                }
+            }
+
+            // Get the next key
+            key_result = string_iter.next();
+        }
+
+        // Use the intermediate representation to return the struct
+        std::result::Result::Ok(WorkEntity {
+            state: intermediate_rep.state.into_iter().next(),
+            ident: intermediate_rep.ident.into_iter().next(),
+            revision: intermediate_rep.revision.into_iter().next(),
+            redirect: intermediate_rep.redirect.into_iter().next(),
+            extra: intermediate_rep.extra.into_iter().next(),
+            edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+        })
+    }
+}