aboutsummaryrefslogtreecommitdiffstats
path: root/fatcat-openapi/src/models.rs
diff options
context:
space:
mode:
Diffstat (limited to 'fatcat-openapi/src/models.rs')
-rw-r--r--fatcat-openapi/src/models.rs7621
1 files changed, 7621 insertions, 0 deletions
diff --git a/fatcat-openapi/src/models.rs b/fatcat-openapi/src/models.rs
new file mode 100644
index 0000000..d642c62
--- /dev/null
+++ b/fatcat-openapi/src/models.rs
@@ -0,0 +1,7621 @@
+#![allow(unused_qualifications)]
+
+#[cfg(any(feature = "client", feature = "server"))]
+use crate::header;
+use crate::models;
+
+// Methods for converting between header::IntoHeaderValue<AuthOidc> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidc>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<AuthOidc>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for AuthOidc - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidc> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <AuthOidc as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into AuthOidc - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct AuthOidc {
+ /// Fatcat-specific short name (slug) for remote service being used for authentication.
+ #[serde(rename = "provider")]
+ pub provider: String,
+
+ /// `SUB` from OIDC protocol. Usually a URL.
+ #[serde(rename = "sub")]
+ pub sub: String,
+
+ /// `ISS` from OIDC protocol. Usually a stable account username, number, or identifier.
+ #[serde(rename = "iss")]
+ pub iss: String,
+
+ /// What it sounds like; returned by OIDC, and used as a hint when creating new editor accounts. Fatcat usernames are usually this string with the `provider` slug as a suffix, though some munging may occur.
+ #[serde(rename = "preferred_username")]
+ pub preferred_username: String,
+}
+
+impl AuthOidc {
+ pub fn new(provider: String, sub: String, iss: String, preferred_username: String) -> AuthOidc {
+ AuthOidc {
+ provider: provider,
+ sub: sub,
+ iss: iss,
+ preferred_username: preferred_username,
+ }
+ }
+}
+
+/// Converts the AuthOidc value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for AuthOidc {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("provider".to_string());
+ params.push(self.provider.to_string());
+
+ params.push("sub".to_string());
+ params.push(self.sub.to_string());
+
+ params.push("iss".to_string());
+ params.push(self.iss.to_string());
+
+ params.push("preferred_username".to_string());
+ params.push(self.preferred_username.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidc value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for AuthOidc {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub provider: Vec<String>,
+ pub sub: Vec<String>,
+ pub iss: Vec<String>,
+ pub preferred_username: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing AuthOidc".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "provider" => intermediate_rep
+ .provider
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "sub" => intermediate_rep
+ .sub
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "iss" => intermediate_rep
+ .iss
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "preferred_username" => intermediate_rep
+ .preferred_username
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing AuthOidc".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(AuthOidc {
+ provider: intermediate_rep
+ .provider
+ .into_iter()
+ .next()
+ .ok_or("provider missing in AuthOidc".to_string())?,
+ sub: intermediate_rep
+ .sub
+ .into_iter()
+ .next()
+ .ok_or("sub missing in AuthOidc".to_string())?,
+ iss: intermediate_rep
+ .iss
+ .into_iter()
+ .next()
+ .ok_or("iss missing in AuthOidc".to_string())?,
+ preferred_username: intermediate_rep
+ .preferred_username
+ .into_iter()
+ .next()
+ .ok_or("preferred_username missing in AuthOidc".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<AuthOidcResult> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<AuthOidcResult>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<AuthOidcResult>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for AuthOidcResult - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<AuthOidcResult> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <AuthOidcResult as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into AuthOidcResult - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct AuthOidcResult {
+ #[serde(rename = "editor")]
+ pub editor: models::Editor,
+
+ #[serde(rename = "token")]
+ pub token: String,
+}
+
+impl AuthOidcResult {
+ pub fn new(editor: models::Editor, token: String) -> AuthOidcResult {
+ AuthOidcResult {
+ editor: editor,
+ token: token,
+ }
+ }
+}
+
+/// Converts the AuthOidcResult value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for AuthOidcResult {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editor in query parameter serialization
+
+ params.push("token".to_string());
+ params.push(self.token.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a AuthOidcResult value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for AuthOidcResult {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editor: Vec<models::Editor>,
+ pub token: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing AuthOidcResult".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editor" => intermediate_rep
+ .editor
+ .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
+ "token" => intermediate_rep
+ .token
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing AuthOidcResult".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(AuthOidcResult {
+ editor: intermediate_rep
+ .editor
+ .into_iter()
+ .next()
+ .ok_or("editor missing in AuthOidcResult".to_string())?,
+ token: intermediate_rep
+ .token
+ .into_iter()
+ .next()
+ .ok_or("token missing in AuthOidcResult".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<AuthTokenResult> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<AuthTokenResult>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<AuthTokenResult>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for AuthTokenResult - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<AuthTokenResult>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <AuthTokenResult as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into AuthTokenResult - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct AuthTokenResult {
+ #[serde(rename = "token")]
+ pub token: String,
+}
+
+impl AuthTokenResult {
+ pub fn new(token: String) -> AuthTokenResult {
+ AuthTokenResult { token: token }
+ }
+}
+
+/// Converts the AuthTokenResult value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for AuthTokenResult {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("token".to_string());
+ params.push(self.token.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a AuthTokenResult value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for AuthTokenResult {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub token: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing AuthTokenResult".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "token" => intermediate_rep
+ .token
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing AuthTokenResult".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(AuthTokenResult {
+ token: intermediate_rep
+ .token
+ .into_iter()
+ .next()
+ .ok_or("token missing in AuthTokenResult".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ChangelogEntry> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ChangelogEntry>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ChangelogEntry>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ChangelogEntry - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ChangelogEntry> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ChangelogEntry as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ChangelogEntry - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ChangelogEntry {
+ /// Monotonically increasing sequence number of this changelog entry.
+ #[serde(rename = "index")]
+ pub index: i64,
+
+ /// Identifier of editgroup accepted/merged in this changelog entry.
+ #[serde(rename = "editgroup_id")]
+ pub editgroup_id: String,
+
+ /// Date and time when the editgroup was accpeted.
+ #[serde(rename = "timestamp")]
+ pub timestamp: chrono::DateTime<chrono::Utc>,
+
+ #[serde(rename = "editgroup")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editgroup: Option<models::Editgroup>,
+}
+
+impl ChangelogEntry {
+ pub fn new(
+ index: i64,
+ editgroup_id: String,
+ timestamp: chrono::DateTime<chrono::Utc>,
+ ) -> ChangelogEntry {
+ ChangelogEntry {
+ index: index,
+ editgroup_id: editgroup_id,
+ timestamp: timestamp,
+ editgroup: None,
+ }
+ }
+}
+
+/// Converts the ChangelogEntry value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ChangelogEntry {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("index".to_string());
+ params.push(self.index.to_string());
+
+ params.push("editgroup_id".to_string());
+ params.push(self.editgroup_id.to_string());
+
+ // Skipping timestamp in query parameter serialization
+
+ // Skipping editgroup in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ChangelogEntry value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ChangelogEntry {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub index: Vec<i64>,
+ pub editgroup_id: Vec<String>,
+ pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+ pub editgroup: Vec<models::Editgroup>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ChangelogEntry".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "index" => intermediate_rep
+ .index
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "editgroup_id" => intermediate_rep
+ .editgroup_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "timestamp" => intermediate_rep.timestamp.push(
+ chrono::DateTime::<chrono::Utc>::from_str(val)
+ .map_err(|x| format!("{}", x))?,
+ ),
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ChangelogEntry".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ChangelogEntry {
+ index: intermediate_rep
+ .index
+ .into_iter()
+ .next()
+ .ok_or("index missing in ChangelogEntry".to_string())?,
+ editgroup_id: intermediate_rep
+ .editgroup_id
+ .into_iter()
+ .next()
+ .ok_or("editgroup_id missing in ChangelogEntry".to_string())?,
+ timestamp: intermediate_rep
+ .timestamp
+ .into_iter()
+ .next()
+ .ok_or("timestamp missing in ChangelogEntry".to_string())?,
+ editgroup: intermediate_rep.editgroup.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ContainerAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ContainerAutoBatch>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ContainerAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ContainerAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<ContainerAutoBatch>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ContainerAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ContainerAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ContainerAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::ContainerEntity>,
+}
+
+impl ContainerAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::ContainerEntity>,
+ ) -> ContainerAutoBatch {
+ ContainerAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the ContainerAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ContainerAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ContainerAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ContainerAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::ContainerEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ContainerAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ContainerAutoBatch"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ContainerAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ContainerAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in ContainerAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in ContainerAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ContainerEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ContainerEntity>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ContainerEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ContainerEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<ContainerEntity>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ContainerEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ContainerEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ContainerEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Name of the container (eg, Journal title). Required for entity creation.
+ #[serde(rename = "name")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub name: Option<String>,
+
+ /// Type of container, eg 'journal' or 'proceedings'. See Guide for list of valid types.
+ #[serde(rename = "container_type")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub container_type: Option<String>,
+
+ /// Name of the organization or entity responsible for publication. Not the complete imprint/brand.
+ #[serde(rename = "publisher")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub publisher: Option<String>,
+
+ /// Linking ISSN number (ISSN-L). Should be valid and registered with issn.org
+ #[serde(rename = "issnl")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub issnl: Option<String>,
+
+ #[serde(rename = "wikidata_qid")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub wikidata_qid: Option<String>,
+}
+
+impl ContainerEntity {
+ pub fn new() -> ContainerEntity {
+ ContainerEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ name: None,
+ container_type: None,
+ publisher: None,
+ issnl: None,
+ wikidata_qid: None,
+ }
+ }
+}
+
+/// Converts the ContainerEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ContainerEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ if let Some(ref name) = self.name {
+ params.push("name".to_string());
+ params.push(name.to_string());
+ }
+
+ if let Some(ref container_type) = self.container_type {
+ params.push("container_type".to_string());
+ params.push(container_type.to_string());
+ }
+
+ if let Some(ref publisher) = self.publisher {
+ params.push("publisher".to_string());
+ params.push(publisher.to_string());
+ }
+
+ if let Some(ref issnl) = self.issnl {
+ params.push("issnl".to_string());
+ params.push(issnl.to_string());
+ }
+
+ if let Some(ref wikidata_qid) = self.wikidata_qid {
+ params.push("wikidata_qid".to_string());
+ params.push(wikidata_qid.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ContainerEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ContainerEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub name: Vec<String>,
+ pub container_type: Vec<String>,
+ pub publisher: Vec<String>,
+ pub issnl: Vec<String>,
+ pub wikidata_qid: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ContainerEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ContainerEntity"
+ .to_string(),
+ )
+ }
+ "edit_extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ContainerEntity"
+ .to_string(),
+ )
+ }
+ "name" => intermediate_rep
+ .name
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "container_type" => intermediate_rep
+ .container_type
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "publisher" => intermediate_rep
+ .publisher
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "issnl" => intermediate_rep
+ .issnl
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "wikidata_qid" => intermediate_rep
+ .wikidata_qid
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ContainerEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ContainerEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ name: intermediate_rep.name.into_iter().next(),
+ container_type: intermediate_rep.container_type.into_iter().next(),
+ publisher: intermediate_rep.publisher.into_iter().next(),
+ issnl: intermediate_rep.issnl.into_iter().next(),
+ wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<CreatorAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<CreatorAutoBatch>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<CreatorAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for CreatorAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<CreatorAutoBatch>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <CreatorAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into CreatorAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct CreatorAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::CreatorEntity>,
+}
+
+impl CreatorAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::CreatorEntity>,
+ ) -> CreatorAutoBatch {
+ CreatorAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the CreatorAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for CreatorAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a CreatorAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for CreatorAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::CreatorEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing CreatorAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in CreatorAutoBatch"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing CreatorAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(CreatorAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in CreatorAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in CreatorAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<CreatorEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<CreatorEntity>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<CreatorEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for CreatorEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<CreatorEntity> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <CreatorEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into CreatorEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct CreatorEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Name as should be displayed in web interface or in author lists (not index/sorted). Required for valid entities.
+ #[serde(rename = "display_name")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub display_name: Option<String>,
+
+ /// In English commonly the first name, but ordering is context and culture specific.
+ #[serde(rename = "given_name")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub given_name: Option<String>,
+
+ /// In English commonly the last, or family name, but ordering is context and culture specific.
+ #[serde(rename = "surname")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub surname: Option<String>,
+
+ /// ORCiD (https://orcid.org) identifier
+ #[serde(rename = "orcid")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub orcid: Option<String>,
+
+ /// Wikidata entity QID
+ #[serde(rename = "wikidata_qid")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub wikidata_qid: Option<String>,
+}
+
+impl CreatorEntity {
+ pub fn new() -> CreatorEntity {
+ CreatorEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ display_name: None,
+ given_name: None,
+ surname: None,
+ orcid: None,
+ wikidata_qid: None,
+ }
+ }
+}
+
+/// Converts the CreatorEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for CreatorEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ if let Some(ref display_name) = self.display_name {
+ params.push("display_name".to_string());
+ params.push(display_name.to_string());
+ }
+
+ if let Some(ref given_name) = self.given_name {
+ params.push("given_name".to_string());
+ params.push(given_name.to_string());
+ }
+
+ if let Some(ref surname) = self.surname {
+ params.push("surname".to_string());
+ params.push(surname.to_string());
+ }
+
+ if let Some(ref orcid) = self.orcid {
+ params.push("orcid".to_string());
+ params.push(orcid.to_string());
+ }
+
+ if let Some(ref wikidata_qid) = self.wikidata_qid {
+ params.push("wikidata_qid".to_string());
+ params.push(wikidata_qid.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a CreatorEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for CreatorEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub display_name: Vec<String>,
+ pub given_name: Vec<String>,
+ pub surname: Vec<String>,
+ pub orcid: Vec<String>,
+ pub wikidata_qid: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing CreatorEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in CreatorEntity"
+ .to_string(),
+ )
+ }
+ "edit_extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in CreatorEntity"
+ .to_string(),
+ )
+ }
+ "display_name" => intermediate_rep
+ .display_name
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "given_name" => intermediate_rep
+ .given_name
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "surname" => intermediate_rep
+ .surname
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "orcid" => intermediate_rep
+ .orcid
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "wikidata_qid" => intermediate_rep
+ .wikidata_qid
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing CreatorEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(CreatorEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ display_name: intermediate_rep.display_name.into_iter().next(),
+ given_name: intermediate_rep.given_name.into_iter().next(),
+ surname: intermediate_rep.surname.into_iter().next(),
+ orcid: intermediate_rep.orcid.into_iter().next(),
+ wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<Editgroup> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<Editgroup>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<Editgroup>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for Editgroup - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editgroup> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <Editgroup as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into Editgroup - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct Editgroup {
+ /// Fatcat identifier for this editgroup. Assigned on creation.
+ #[serde(rename = "editgroup_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editgroup_id: Option<String>,
+
+ /// Fatcat identifer of editor that created this editgroup.
+ #[serde(rename = "editor_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editor_id: Option<String>,
+
+ #[serde(rename = "editor")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editor: Option<models::Editor>,
+
+ /// For accepted/merged editgroups, the changelog index that the accept occured at. WARNING: not populated in all contexts that an editgroup could be included in a response.
+ #[serde(rename = "changelog_index")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub changelog_index: Option<i64>,
+
+ /// Timestamp when this editgroup was first created.
+ #[serde(rename = "created")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub created: Option<chrono::DateTime<chrono::Utc>>,
+
+ /// Timestamp when this editgroup was most recently submitted for review. If withdrawn, or never submitted, will be `null`.
+ #[serde(rename = "submitted")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub submitted: Option<chrono::DateTime<chrono::Utc>>,
+
+ /// Comment describing the changes in this editgroup. Can be updated with PUT request.
+ #[serde(rename = "description")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub description: Option<String>,
+
+ /// Free-form JSON metadata attached to this editgroup. Eg, metadata provenance, or script user-agent details. See guide for (unenforced) schema norms.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
+ #[serde(rename = "annotations")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub annotations: Option<Vec<models::EditgroupAnnotation>>,
+
+ #[serde(rename = "edits")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edits: Option<models::EditgroupEdits>,
+}
+
+impl Editgroup {
+ pub fn new() -> Editgroup {
+ Editgroup {
+ editgroup_id: None,
+ editor_id: None,
+ editor: None,
+ changelog_index: None,
+ created: None,
+ submitted: None,
+ description: None,
+ extra: None,
+ annotations: None,
+ edits: None,
+ }
+ }
+}
+
+/// Converts the Editgroup value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for Editgroup {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref editgroup_id) = self.editgroup_id {
+ params.push("editgroup_id".to_string());
+ params.push(editgroup_id.to_string());
+ }
+
+ if let Some(ref editor_id) = self.editor_id {
+ params.push("editor_id".to_string());
+ params.push(editor_id.to_string());
+ }
+
+ // Skipping editor in query parameter serialization
+
+ if let Some(ref changelog_index) = self.changelog_index {
+ params.push("changelog_index".to_string());
+ params.push(changelog_index.to_string());
+ }
+
+ // Skipping created in query parameter serialization
+
+ // Skipping submitted in query parameter serialization
+
+ if let Some(ref description) = self.description {
+ params.push("description".to_string());
+ params.push(description.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping annotations in query parameter serialization
+
+ // Skipping edits in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a Editgroup value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for Editgroup {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup_id: Vec<String>,
+ pub editor_id: Vec<String>,
+ pub editor: Vec<models::Editor>,
+ pub changelog_index: Vec<i64>,
+ pub created: Vec<chrono::DateTime<chrono::Utc>>,
+ pub submitted: Vec<chrono::DateTime<chrono::Utc>>,
+ pub description: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub annotations: Vec<Vec<models::EditgroupAnnotation>>,
+ pub edits: Vec<models::EditgroupEdits>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing Editgroup".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup_id" => intermediate_rep
+ .editgroup_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "editor_id" => intermediate_rep
+ .editor_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "editor" => intermediate_rep
+ .editor
+ .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
+ "changelog_index" => intermediate_rep
+ .changelog_index
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "created" => intermediate_rep.created.push(
+ chrono::DateTime::<chrono::Utc>::from_str(val)
+ .map_err(|x| format!("{}", x))?,
+ ),
+ "submitted" => intermediate_rep.submitted.push(
+ chrono::DateTime::<chrono::Utc>::from_str(val)
+ .map_err(|x| format!("{}", x))?,
+ ),
+ "description" => intermediate_rep
+ .description
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in Editgroup"
+ .to_string(),
+ )
+ }
+ "annotations" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in Editgroup"
+ .to_string(),
+ )
+ }
+ "edits" => intermediate_rep
+ .edits
+ .push(models::EditgroupEdits::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing Editgroup".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(Editgroup {
+ editgroup_id: intermediate_rep.editgroup_id.into_iter().next(),
+ editor_id: intermediate_rep.editor_id.into_iter().next(),
+ editor: intermediate_rep.editor.into_iter().next(),
+ changelog_index: intermediate_rep.changelog_index.into_iter().next(),
+ created: intermediate_rep.created.into_iter().next(),
+ submitted: intermediate_rep.submitted.into_iter().next(),
+ description: intermediate_rep.description.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ annotations: intermediate_rep.annotations.into_iter().next(),
+ edits: intermediate_rep.edits.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<EditgroupAnnotation> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupAnnotation>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<EditgroupAnnotation>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for EditgroupAnnotation - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<EditgroupAnnotation>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <EditgroupAnnotation as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into EditgroupAnnotation - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct EditgroupAnnotation {
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "annotation_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub annotation_id: Option<String>,
+
+ /// Editgroup that this annotation applies to. Set automatically in creations based on URL parameter.
+ #[serde(rename = "editgroup_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editgroup_id: Option<String>,
+
+ /// Defaults to editor created the annotation via POST request.
+ #[serde(rename = "editor_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editor_id: Option<String>,
+
+ #[serde(rename = "editor")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editor: Option<models::Editor>,
+
+ /// Timestamp when annotation was first created.
+ #[serde(rename = "created")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub created: Option<chrono::DateTime<chrono::Utc>>,
+
+ #[serde(rename = "comment_markdown")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub comment_markdown: Option<String>,
+
+ /// Additional free-form JSON metadata that can be included as part of the annotation (or even as the primary annotation itself). See guide for details.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl EditgroupAnnotation {
+ pub fn new() -> EditgroupAnnotation {
+ EditgroupAnnotation {
+ annotation_id: None,
+ editgroup_id: None,
+ editor_id: None,
+ editor: None,
+ created: None,
+ comment_markdown: None,
+ extra: None,
+ }
+ }
+}
+
+/// Converts the EditgroupAnnotation value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for EditgroupAnnotation {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref annotation_id) = self.annotation_id {
+ params.push("annotation_id".to_string());
+ params.push(annotation_id.to_string());
+ }
+
+ if let Some(ref editgroup_id) = self.editgroup_id {
+ params.push("editgroup_id".to_string());
+ params.push(editgroup_id.to_string());
+ }
+
+ if let Some(ref editor_id) = self.editor_id {
+ params.push("editor_id".to_string());
+ params.push(editor_id.to_string());
+ }
+
+ // Skipping editor in query parameter serialization
+
+ // Skipping created in query parameter serialization
+
+ if let Some(ref comment_markdown) = self.comment_markdown {
+ params.push("comment_markdown".to_string());
+ params.push(comment_markdown.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupAnnotation value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for EditgroupAnnotation {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub annotation_id: Vec<String>,
+ pub editgroup_id: Vec<String>,
+ pub editor_id: Vec<String>,
+ pub editor: Vec<models::Editor>,
+ pub created: Vec<chrono::DateTime<chrono::Utc>>,
+ pub comment_markdown: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing EditgroupAnnotation".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "annotation_id" => intermediate_rep
+ .annotation_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "editgroup_id" => intermediate_rep
+ .editgroup_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "editor_id" => intermediate_rep
+ .editor_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "editor" => intermediate_rep
+ .editor
+ .push(models::Editor::from_str(val).map_err(|x| format!("{}", x))?),
+ "created" => intermediate_rep.created.push(
+ chrono::DateTime::<chrono::Utc>::from_str(val)
+ .map_err(|x| format!("{}", x))?,
+ ),
+ "comment_markdown" => intermediate_rep
+ .comment_markdown
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupAnnotation"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing EditgroupAnnotation".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(EditgroupAnnotation {
+ annotation_id: intermediate_rep.annotation_id.into_iter().next(),
+ editgroup_id: intermediate_rep.editgroup_id.into_iter().next(),
+ editor_id: intermediate_rep.editor_id.into_iter().next(),
+ editor: intermediate_rep.editor.into_iter().next(),
+ created: intermediate_rep.created.into_iter().next(),
+ comment_markdown: intermediate_rep.comment_markdown.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ })
+ }
+}
+
+/// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
+// Methods for converting between header::IntoHeaderValue<EditgroupEdits> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<EditgroupEdits>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<EditgroupEdits>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for EditgroupEdits - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EditgroupEdits> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <EditgroupEdits as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into EditgroupEdits - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct EditgroupEdits {
+ #[serde(rename = "containers")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub containers: Option<Vec<models::EntityEdit>>,
+
+ #[serde(rename = "creators")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub creators: Option<Vec<models::EntityEdit>>,
+
+ #[serde(rename = "files")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub files: Option<Vec<models::EntityEdit>>,
+
+ #[serde(rename = "filesets")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub filesets: Option<Vec<models::EntityEdit>>,
+
+ #[serde(rename = "webcaptures")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub webcaptures: Option<Vec<models::EntityEdit>>,
+
+ #[serde(rename = "releases")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub releases: Option<Vec<models::EntityEdit>>,
+
+ #[serde(rename = "works")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub works: Option<Vec<models::EntityEdit>>,
+}
+
+impl EditgroupEdits {
+ pub fn new() -> EditgroupEdits {
+ EditgroupEdits {
+ containers: None,
+ creators: None,
+ files: None,
+ filesets: None,
+ webcaptures: None,
+ releases: None,
+ works: None,
+ }
+ }
+}
+
+/// Converts the EditgroupEdits value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for EditgroupEdits {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping containers in query parameter serialization
+
+ // Skipping creators in query parameter serialization
+
+ // Skipping files in query parameter serialization
+
+ // Skipping filesets in query parameter serialization
+
+ // Skipping webcaptures in query parameter serialization
+
+ // Skipping releases in query parameter serialization
+
+ // Skipping works in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a EditgroupEdits value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for EditgroupEdits {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub containers: Vec<Vec<models::EntityEdit>>,
+ pub creators: Vec<Vec<models::EntityEdit>>,
+ pub files: Vec<Vec<models::EntityEdit>>,
+ pub filesets: Vec<Vec<models::EntityEdit>>,
+ pub webcaptures: Vec<Vec<models::EntityEdit>>,
+ pub releases: Vec<Vec<models::EntityEdit>>,
+ pub works: Vec<Vec<models::EntityEdit>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing EditgroupEdits".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "containers" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ "creators" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ "files" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ "filesets" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ "webcaptures" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ "releases" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ "works" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EditgroupEdits"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing EditgroupEdits".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(EditgroupEdits {
+ containers: intermediate_rep.containers.into_iter().next(),
+ creators: intermediate_rep.creators.into_iter().next(),
+ files: intermediate_rep.files.into_iter().next(),
+ filesets: intermediate_rep.filesets.into_iter().next(),
+ webcaptures: intermediate_rep.webcaptures.into_iter().next(),
+ releases: intermediate_rep.releases.into_iter().next(),
+ works: intermediate_rep.works.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<Editor> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<Editor>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<Editor>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for Editor - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Editor> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <Editor as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into Editor - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct Editor {
+ /// Fatcat identifier for the editor. Can not be changed.
+ #[serde(rename = "editor_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub editor_id: Option<String>,
+
+ /// Username/handle (short slug-like string) to identify this editor. May be changed at any time by the editor; use the `editor_id` as a persistend identifer.
+ #[serde(rename = "username")]
+ pub username: String,
+
+ /// Whether this editor has the `admin` role.
+ #[serde(rename = "is_admin")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub is_admin: Option<bool>,
+
+ /// Whether this editor is a bot (as opposed to a human making manual edits)
+ #[serde(rename = "is_bot")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub is_bot: Option<bool>,
+
+ /// Whether this editor's account is enabled (if not API tokens and web logins will not work).
+ #[serde(rename = "is_active")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub is_active: Option<bool>,
+}
+
+impl Editor {
+ pub fn new(username: String) -> Editor {
+ Editor {
+ editor_id: None,
+ username: username,
+ is_admin: None,
+ is_bot: None,
+ is_active: None,
+ }
+ }
+}
+
+/// Converts the Editor value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for Editor {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref editor_id) = self.editor_id {
+ params.push("editor_id".to_string());
+ params.push(editor_id.to_string());
+ }
+
+ params.push("username".to_string());
+ params.push(self.username.to_string());
+
+ if let Some(ref is_admin) = self.is_admin {
+ params.push("is_admin".to_string());
+ params.push(is_admin.to_string());
+ }
+
+ if let Some(ref is_bot) = self.is_bot {
+ params.push("is_bot".to_string());
+ params.push(is_bot.to_string());
+ }
+
+ if let Some(ref is_active) = self.is_active {
+ params.push("is_active".to_string());
+ params.push(is_active.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a Editor value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for Editor {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editor_id: Vec<String>,
+ pub username: Vec<String>,
+ pub is_admin: Vec<bool>,
+ pub is_bot: Vec<bool>,
+ pub is_active: Vec<bool>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing Editor".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editor_id" => intermediate_rep
+ .editor_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "username" => intermediate_rep
+ .username
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "is_admin" => intermediate_rep
+ .is_admin
+ .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+ "is_bot" => intermediate_rep
+ .is_bot
+ .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+ "is_active" => intermediate_rep
+ .is_active
+ .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing Editor".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(Editor {
+ editor_id: intermediate_rep.editor_id.into_iter().next(),
+ username: intermediate_rep
+ .username
+ .into_iter()
+ .next()
+ .ok_or("username missing in Editor".to_string())?,
+ is_admin: intermediate_rep.is_admin.into_iter().next(),
+ is_bot: intermediate_rep.is_bot.into_iter().next(),
+ is_active: intermediate_rep.is_active.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<EntityEdit> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<EntityEdit>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<EntityEdit>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for EntityEdit - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<EntityEdit> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <EntityEdit as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into EntityEdit - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct EntityEdit {
+ /// Unique UUID for this specific edit object.
+ #[serde(rename = "edit_id")]
+ pub edit_id: String,
+
+ /// Fatcat identifier of the entity this edit is mutating.
+ #[serde(rename = "ident")]
+ pub ident: String,
+
+ /// Entity revision that this edit will set the entity to. May be `null` in the case of deletions.
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// Revision of entity just before this edit. May be used in the future to prevent edit race conditions.
+ #[serde(rename = "prev_revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub prev_revision: Option<String>,
+
+ /// When an edit is to merge entities (redirect one to another), this is the entity fatcat identifier for the target entity.
+ #[serde(rename = "redirect_ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect_ident: Option<String>,
+
+ /// Editgroup identifier that this edit is part of.
+ #[serde(rename = "editgroup_id")]
+ pub editgroup_id: String,
+
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl EntityEdit {
+ pub fn new(edit_id: String, ident: String, editgroup_id: String) -> EntityEdit {
+ EntityEdit {
+ edit_id: edit_id,
+ ident: ident,
+ revision: None,
+ prev_revision: None,
+ redirect_ident: None,
+ editgroup_id: editgroup_id,
+ extra: None,
+ }
+ }
+}
+
+/// Converts the EntityEdit value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for EntityEdit {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("edit_id".to_string());
+ params.push(self.edit_id.to_string());
+
+ params.push("ident".to_string());
+ params.push(self.ident.to_string());
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref prev_revision) = self.prev_revision {
+ params.push("prev_revision".to_string());
+ params.push(prev_revision.to_string());
+ }
+
+ if let Some(ref redirect_ident) = self.redirect_ident {
+ params.push("redirect_ident".to_string());
+ params.push(redirect_ident.to_string());
+ }
+
+ params.push("editgroup_id".to_string());
+ params.push(self.editgroup_id.to_string());
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a EntityEdit value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for EntityEdit {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub edit_id: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub prev_revision: Vec<String>,
+ pub redirect_ident: Vec<String>,
+ pub editgroup_id: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing EntityEdit".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "edit_id" => intermediate_rep
+ .edit_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "prev_revision" => intermediate_rep
+ .prev_revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect_ident" => intermediate_rep
+ .redirect_ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "editgroup_id" => intermediate_rep
+ .editgroup_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in EntityEdit"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing EntityEdit".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(EntityEdit {
+ edit_id: intermediate_rep
+ .edit_id
+ .into_iter()
+ .next()
+ .ok_or("edit_id missing in EntityEdit".to_string())?,
+ ident: intermediate_rep
+ .ident
+ .into_iter()
+ .next()
+ .ok_or("ident missing in EntityEdit".to_string())?,
+ revision: intermediate_rep.revision.into_iter().next(),
+ prev_revision: intermediate_rep.prev_revision.into_iter().next(),
+ redirect_ident: intermediate_rep.redirect_ident.into_iter().next(),
+ editgroup_id: intermediate_rep
+ .editgroup_id
+ .into_iter()
+ .next()
+ .ok_or("editgroup_id missing in EntityEdit".to_string())?,
+ extra: intermediate_rep.extra.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<EntityHistoryEntry> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<EntityHistoryEntry>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<EntityHistoryEntry>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for EntityHistoryEntry - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<EntityHistoryEntry>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <EntityHistoryEntry as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into EntityHistoryEntry - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct EntityHistoryEntry {
+ #[serde(rename = "edit")]
+ pub edit: models::EntityEdit,
+
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "changelog_entry")]
+ pub changelog_entry: models::ChangelogEntry,
+}
+
+impl EntityHistoryEntry {
+ pub fn new(
+ edit: models::EntityEdit,
+ editgroup: models::Editgroup,
+ changelog_entry: models::ChangelogEntry,
+ ) -> EntityHistoryEntry {
+ EntityHistoryEntry {
+ edit: edit,
+ editgroup: editgroup,
+ changelog_entry: changelog_entry,
+ }
+ }
+}
+
+/// Converts the EntityHistoryEntry value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for EntityHistoryEntry {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping edit in query parameter serialization
+
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping changelog_entry in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a EntityHistoryEntry value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for EntityHistoryEntry {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub edit: Vec<models::EntityEdit>,
+ pub editgroup: Vec<models::Editgroup>,
+ pub changelog_entry: Vec<models::ChangelogEntry>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing EntityHistoryEntry".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "edit" => intermediate_rep
+ .edit
+ .push(models::EntityEdit::from_str(val).map_err(|x| format!("{}", x))?),
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "changelog_entry" => intermediate_rep
+ .changelog_entry
+ .push(models::ChangelogEntry::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing EntityHistoryEntry".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(EntityHistoryEntry {
+ edit: intermediate_rep
+ .edit
+ .into_iter()
+ .next()
+ .ok_or("edit missing in EntityHistoryEntry".to_string())?,
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in EntityHistoryEntry".to_string())?,
+ changelog_entry: intermediate_rep
+ .changelog_entry
+ .into_iter()
+ .next()
+ .ok_or("changelog_entry missing in EntityHistoryEntry".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ErrorResponse> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ErrorResponse>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ErrorResponse>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ErrorResponse - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ErrorResponse> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ErrorResponse as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ErrorResponse - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ErrorResponse {
+ #[serde(rename = "success")]
+ pub success: bool,
+
+ #[serde(rename = "error")]
+ pub error: String,
+
+ #[serde(rename = "message")]
+ pub message: String,
+}
+
+impl ErrorResponse {
+ pub fn new(success: bool, error: String, message: String) -> ErrorResponse {
+ ErrorResponse {
+ success: success,
+ error: error,
+ message: message,
+ }
+ }
+}
+
+/// Converts the ErrorResponse value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ErrorResponse {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("success".to_string());
+ params.push(self.success.to_string());
+
+ params.push("error".to_string());
+ params.push(self.error.to_string());
+
+ params.push("message".to_string());
+ params.push(self.message.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ErrorResponse value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ErrorResponse {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub success: Vec<bool>,
+ pub error: Vec<String>,
+ pub message: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ErrorResponse".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "success" => intermediate_rep
+ .success
+ .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+ "error" => intermediate_rep
+ .error
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "message" => intermediate_rep
+ .message
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ErrorResponse".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ErrorResponse {
+ success: intermediate_rep
+ .success
+ .into_iter()
+ .next()
+ .ok_or("success missing in ErrorResponse".to_string())?,
+ error: intermediate_rep
+ .error
+ .into_iter()
+ .next()
+ .ok_or("error missing in ErrorResponse".to_string())?,
+ message: intermediate_rep
+ .message
+ .into_iter()
+ .next()
+ .ok_or("message missing in ErrorResponse".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FileAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FileAutoBatch>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FileAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FileAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileAutoBatch> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FileAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FileAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FileAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::FileEntity>,
+}
+
+impl FileAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::FileEntity>,
+ ) -> FileAutoBatch {
+ FileAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the FileAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FileAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FileAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FileAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::FileEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FileAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FileAutoBatch"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FileAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FileAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in FileAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in FileAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FileEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FileEntity>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FileEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FileEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileEntity> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FileEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FileEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FileEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Size of file in bytes. Non-zero.
+ #[serde(rename = "size")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub size: Option<i64>,
+
+ /// MD5 hash of data, in hex encoding
+ #[serde(rename = "md5")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub md5: Option<String>,
+
+ /// SHA-1 hash of data, in hex encoding
+ #[serde(rename = "sha1")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub sha1: Option<String>,
+
+ /// SHA-256 hash of data, in hex encoding
+ #[serde(rename = "sha256")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub sha256: Option<String>,
+
+ #[serde(rename = "urls")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub urls: Option<Vec<models::FileUrl>>,
+
+ #[serde(rename = "mimetype")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub mimetype: Option<String>,
+
+ /// Set of identifier of release entities this file represents a full manifestation of. Usually a single release, but some files contain content of multiple full releases (eg, an issue of a journal).
+ #[serde(rename = "release_ids")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_ids: Option<Vec<String>>,
+
+ /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
+ #[serde(rename = "releases")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub releases: Option<Vec<models::ReleaseEntity>>,
+}
+
+impl FileEntity {
+ pub fn new() -> FileEntity {
+ FileEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ size: None,
+ md5: None,
+ sha1: None,
+ sha256: None,
+ urls: None,
+ mimetype: None,
+ release_ids: None,
+ releases: None,
+ }
+ }
+}
+
+/// Converts the FileEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FileEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ if let Some(ref size) = self.size {
+ params.push("size".to_string());
+ params.push(size.to_string());
+ }
+
+ if let Some(ref md5) = self.md5 {
+ params.push("md5".to_string());
+ params.push(md5.to_string());
+ }
+
+ if let Some(ref sha1) = self.sha1 {
+ params.push("sha1".to_string());
+ params.push(sha1.to_string());
+ }
+
+ if let Some(ref sha256) = self.sha256 {
+ params.push("sha256".to_string());
+ params.push(sha256.to_string());
+ }
+
+ // Skipping urls in query parameter serialization
+
+ if let Some(ref mimetype) = self.mimetype {
+ params.push("mimetype".to_string());
+ params.push(mimetype.to_string());
+ }
+
+ if let Some(ref release_ids) = self.release_ids {
+ params.push("release_ids".to_string());
+ params.push(
+ release_ids
+ .iter()
+ .map(|x| x.to_string())
+ .collect::<Vec<_>>()
+ .join(",")
+ .to_string(),
+ );
+ }
+
+ // Skipping releases in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FileEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FileEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub size: Vec<i64>,
+ pub md5: Vec<String>,
+ pub sha1: Vec<String>,
+ pub sha256: Vec<String>,
+ pub urls: Vec<Vec<models::FileUrl>>,
+ pub mimetype: Vec<String>,
+ pub release_ids: Vec<Vec<String>>,
+ pub releases: Vec<Vec<models::ReleaseEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FileEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FileEntity"
+ .to_string(),
+ )
+ }
+ "edit_extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FileEntity"
+ .to_string(),
+ )
+ }
+ "size" => intermediate_rep
+ .size
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "md5" => intermediate_rep
+ .md5
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "sha1" => intermediate_rep
+ .sha1
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "sha256" => intermediate_rep
+ .sha256
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "urls" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FileEntity"
+ .to_string(),
+ )
+ }
+ "mimetype" => intermediate_rep
+ .mimetype
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "release_ids" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FileEntity"
+ .to_string(),
+ )
+ }
+ "releases" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FileEntity"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FileEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FileEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ size: intermediate_rep.size.into_iter().next(),
+ md5: intermediate_rep.md5.into_iter().next(),
+ sha1: intermediate_rep.sha1.into_iter().next(),
+ sha256: intermediate_rep.sha256.into_iter().next(),
+ urls: intermediate_rep.urls.into_iter().next(),
+ mimetype: intermediate_rep.mimetype.into_iter().next(),
+ release_ids: intermediate_rep.release_ids.into_iter().next(),
+ releases: intermediate_rep.releases.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FileUrl> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FileUrl>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FileUrl>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FileUrl - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FileUrl> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FileUrl as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FileUrl - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FileUrl {
+ /// URL/URI pointing directly to a machine retrievable copy of this exact file.
+ #[serde(rename = "url")]
+ pub url: String,
+
+ /// Indicates type of host this URL points to. Eg, \"publisher\", \"repository\", \"webarchive\". See guide for list of acceptable values.
+ #[serde(rename = "rel")]
+ pub rel: String,
+}
+
+impl FileUrl {
+ pub fn new(url: String, rel: String) -> FileUrl {
+ FileUrl { url: url, rel: rel }
+ }
+}
+
+/// Converts the FileUrl value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FileUrl {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("url".to_string());
+ params.push(self.url.to_string());
+
+ params.push("rel".to_string());
+ params.push(self.rel.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FileUrl value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FileUrl {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub url: Vec<String>,
+ pub rel: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FileUrl".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "url" => intermediate_rep
+ .url
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "rel" => intermediate_rep
+ .rel
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FileUrl".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FileUrl {
+ url: intermediate_rep
+ .url
+ .into_iter()
+ .next()
+ .ok_or("url missing in FileUrl".to_string())?,
+ rel: intermediate_rep
+ .rel
+ .into_iter()
+ .next()
+ .ok_or("rel missing in FileUrl".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FilesetAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FilesetAutoBatch>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FilesetAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FilesetAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<FilesetAutoBatch>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FilesetAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FilesetAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FilesetAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::FilesetEntity>,
+}
+
+impl FilesetAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::FilesetEntity>,
+ ) -> FilesetAutoBatch {
+ FilesetAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the FilesetAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FilesetAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FilesetAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FilesetAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::FilesetEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FilesetAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetAutoBatch"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FilesetAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FilesetAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in FilesetAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in FilesetAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FilesetEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FilesetEntity>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FilesetEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FilesetEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetEntity> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FilesetEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FilesetEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FilesetEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ #[serde(rename = "manifest")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub manifest: Option<Vec<models::FilesetFile>>,
+
+ #[serde(rename = "urls")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub urls: Option<Vec<models::FilesetUrl>>,
+
+ /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
+ #[serde(rename = "release_ids")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_ids: Option<Vec<String>>,
+
+ /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
+ #[serde(rename = "releases")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub releases: Option<Vec<models::ReleaseEntity>>,
+}
+
+impl FilesetEntity {
+ pub fn new() -> FilesetEntity {
+ FilesetEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ manifest: None,
+ urls: None,
+ release_ids: None,
+ releases: None,
+ }
+ }
+}
+
+/// Converts the FilesetEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FilesetEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ // Skipping manifest in query parameter serialization
+
+ // Skipping urls in query parameter serialization
+
+ if let Some(ref release_ids) = self.release_ids {
+ params.push("release_ids".to_string());
+ params.push(
+ release_ids
+ .iter()
+ .map(|x| x.to_string())
+ .collect::<Vec<_>>()
+ .join(",")
+ .to_string(),
+ );
+ }
+
+ // Skipping releases in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FilesetEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FilesetEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub manifest: Vec<Vec<models::FilesetFile>>,
+ pub urls: Vec<Vec<models::FilesetUrl>>,
+ pub release_ids: Vec<Vec<String>>,
+ pub releases: Vec<Vec<models::ReleaseEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FilesetEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetEntity"
+ .to_string(),
+ )
+ }
+ "edit_extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetEntity"
+ .to_string(),
+ )
+ }
+ "manifest" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetEntity"
+ .to_string(),
+ )
+ }
+ "urls" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetEntity"
+ .to_string(),
+ )
+ }
+ "release_ids" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetEntity"
+ .to_string(),
+ )
+ }
+ "releases" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetEntity"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FilesetEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FilesetEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ manifest: intermediate_rep.manifest.into_iter().next(),
+ urls: intermediate_rep.urls.into_iter().next(),
+ release_ids: intermediate_rep.release_ids.into_iter().next(),
+ releases: intermediate_rep.releases.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FilesetFile> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FilesetFile>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FilesetFile>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FilesetFile - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetFile> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FilesetFile as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FilesetFile - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FilesetFile {
+ /// Path name of file within this fileset (eg, directory)
+ #[serde(rename = "path")]
+ pub path: String,
+
+ /// File size in bytes
+ #[serde(rename = "size")]
+ pub size: i64,
+
+ /// MD5 hash of data, in hex encoding
+ #[serde(rename = "md5")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub md5: Option<String>,
+
+ /// SHA-1 hash of data, in hex encoding
+ #[serde(rename = "sha1")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub sha1: Option<String>,
+
+ /// SHA-256 hash of data, in hex encoding
+ #[serde(rename = "sha256")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub sha256: Option<String>,
+
+ /// Free-form additional metadata about this specific file in the set. Eg, `mimetype`. See guide for nomative (but unenforced) schema fields.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl FilesetFile {
+ pub fn new(path: String, size: i64) -> FilesetFile {
+ FilesetFile {
+ path: path,
+ size: size,
+ md5: None,
+ sha1: None,
+ sha256: None,
+ extra: None,
+ }
+ }
+}
+
+/// Converts the FilesetFile value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FilesetFile {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("path".to_string());
+ params.push(self.path.to_string());
+
+ params.push("size".to_string());
+ params.push(self.size.to_string());
+
+ if let Some(ref md5) = self.md5 {
+ params.push("md5".to_string());
+ params.push(md5.to_string());
+ }
+
+ if let Some(ref sha1) = self.sha1 {
+ params.push("sha1".to_string());
+ params.push(sha1.to_string());
+ }
+
+ if let Some(ref sha256) = self.sha256 {
+ params.push("sha256".to_string());
+ params.push(sha256.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FilesetFile value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FilesetFile {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub path: Vec<String>,
+ pub size: Vec<i64>,
+ pub md5: Vec<String>,
+ pub sha1: Vec<String>,
+ pub sha256: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FilesetFile".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "path" => intermediate_rep
+ .path
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "size" => intermediate_rep
+ .size
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "md5" => intermediate_rep
+ .md5
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "sha1" => intermediate_rep
+ .sha1
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "sha256" => intermediate_rep
+ .sha256
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in FilesetFile"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FilesetFile".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FilesetFile {
+ path: intermediate_rep
+ .path
+ .into_iter()
+ .next()
+ .ok_or("path missing in FilesetFile".to_string())?,
+ size: intermediate_rep
+ .size
+ .into_iter()
+ .next()
+ .ok_or("size missing in FilesetFile".to_string())?,
+ md5: intermediate_rep.md5.into_iter().next(),
+ sha1: intermediate_rep.sha1.into_iter().next(),
+ sha256: intermediate_rep.sha256.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<FilesetUrl> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<FilesetUrl>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<FilesetUrl>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for FilesetUrl - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<FilesetUrl> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <FilesetUrl as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into FilesetUrl - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct FilesetUrl {
+ #[serde(rename = "url")]
+ pub url: String,
+
+ /// Indicates type of host this URL points to. See guide for list of acceptable values.
+ #[serde(rename = "rel")]
+ pub rel: String,
+}
+
+impl FilesetUrl {
+ pub fn new(url: String, rel: String) -> FilesetUrl {
+ FilesetUrl { url: url, rel: rel }
+ }
+}
+
+/// Converts the FilesetUrl value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for FilesetUrl {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("url".to_string());
+ params.push(self.url.to_string());
+
+ params.push("rel".to_string());
+ params.push(self.rel.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a FilesetUrl value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for FilesetUrl {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub url: Vec<String>,
+ pub rel: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing FilesetUrl".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "url" => intermediate_rep
+ .url
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "rel" => intermediate_rep
+ .rel
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing FilesetUrl".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(FilesetUrl {
+ url: intermediate_rep
+ .url
+ .into_iter()
+ .next()
+ .ok_or("url missing in FilesetUrl".to_string())?,
+ rel: intermediate_rep
+ .rel
+ .into_iter()
+ .next()
+ .ok_or("rel missing in FilesetUrl".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseAbstract> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAbstract>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ReleaseAbstract>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ReleaseAbstract - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<ReleaseAbstract>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ReleaseAbstract as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ReleaseAbstract - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseAbstract {
+ /// SHA-1 hash of data, in hex encoding
+ #[serde(rename = "sha1")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub sha1: Option<String>,
+
+ /// Abstract content. May be encoded, as per `mimetype` field, but only string/text content may be included.
+ #[serde(rename = "content")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub content: Option<String>,
+
+ /// Mimetype of abstract contents. `text/plain` is the default if content isn't encoded.
+ #[serde(rename = "mimetype")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub mimetype: Option<String>,
+
+ /// ISO language code of the abstract. Same semantics as release `language` field.
+ #[serde(rename = "lang")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub lang: Option<String>,
+}
+
+impl ReleaseAbstract {
+ pub fn new() -> ReleaseAbstract {
+ ReleaseAbstract {
+ sha1: None,
+ content: None,
+ mimetype: None,
+ lang: None,
+ }
+ }
+}
+
+/// Converts the ReleaseAbstract value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseAbstract {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref sha1) = self.sha1 {
+ params.push("sha1".to_string());
+ params.push(sha1.to_string());
+ }
+
+ if let Some(ref content) = self.content {
+ params.push("content".to_string());
+ params.push(content.to_string());
+ }
+
+ if let Some(ref mimetype) = self.mimetype {
+ params.push("mimetype".to_string());
+ params.push(mimetype.to_string());
+ }
+
+ if let Some(ref lang) = self.lang {
+ params.push("lang".to_string());
+ params.push(lang.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAbstract value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseAbstract {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub sha1: Vec<String>,
+ pub content: Vec<String>,
+ pub mimetype: Vec<String>,
+ pub lang: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ReleaseAbstract".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "sha1" => intermediate_rep
+ .sha1
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "content" => intermediate_rep
+ .content
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "mimetype" => intermediate_rep
+ .mimetype
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "lang" => intermediate_rep
+ .lang
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ReleaseAbstract".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ReleaseAbstract {
+ sha1: intermediate_rep.sha1.into_iter().next(),
+ content: intermediate_rep.content.into_iter().next(),
+ mimetype: intermediate_rep.mimetype.into_iter().next(),
+ lang: intermediate_rep.lang.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseAutoBatch>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ReleaseAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ReleaseAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<ReleaseAutoBatch>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ReleaseAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ReleaseAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::ReleaseEntity>,
+}
+
+impl ReleaseAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::ReleaseEntity>,
+ ) -> ReleaseAutoBatch {
+ ReleaseAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the ReleaseAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::ReleaseEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ReleaseAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseAutoBatch"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ReleaseAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ReleaseAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in ReleaseAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in ReleaseAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseContrib> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseContrib>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ReleaseContrib>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ReleaseContrib - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseContrib> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ReleaseContrib as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ReleaseContrib - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseContrib {
+ /// Internally assigned zero-indexed sequence number of contribution. Authors should come first; this encodes the order of attriubtion.
+ #[serde(rename = "index")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub index: Option<i64>,
+
+ /// If known, indicates the creator entity this contribution was made by.
+ #[serde(rename = "creator_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub creator_id: Option<String>,
+
+ #[serde(rename = "creator")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub creator: Option<models::CreatorEntity>,
+
+ /// Full name of the contributor as typeset in the release.
+ #[serde(rename = "raw_name")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub raw_name: Option<String>,
+
+ /// In English commonly the first name, but ordering is context and culture specific.
+ #[serde(rename = "given_name")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub given_name: Option<String>,
+
+ /// In English commonly the last, or family name, but ordering is context and culture specific.
+ #[serde(rename = "surname")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub surname: Option<String>,
+
+ /// Short string (slug) indicating type of contribution (eg, \"author\", \"translator\"). See guide for list of accpeted values.
+ #[serde(rename = "role")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub role: Option<String>,
+
+ /// Raw affiliation string as displayed in text
+ #[serde(rename = "raw_affiliation")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub raw_affiliation: Option<String>,
+
+ /// Additional free-form JSON metadata about this contributor/contribution. See guide for normative schema.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl ReleaseContrib {
+ pub fn new() -> ReleaseContrib {
+ ReleaseContrib {
+ index: None,
+ creator_id: None,
+ creator: None,
+ raw_name: None,
+ given_name: None,
+ surname: None,
+ role: None,
+ raw_affiliation: None,
+ extra: None,
+ }
+ }
+}
+
+/// Converts the ReleaseContrib value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseContrib {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref index) = self.index {
+ params.push("index".to_string());
+ params.push(index.to_string());
+ }
+
+ if let Some(ref creator_id) = self.creator_id {
+ params.push("creator_id".to_string());
+ params.push(creator_id.to_string());
+ }
+
+ // Skipping creator in query parameter serialization
+
+ if let Some(ref raw_name) = self.raw_name {
+ params.push("raw_name".to_string());
+ params.push(raw_name.to_string());
+ }
+
+ if let Some(ref given_name) = self.given_name {
+ params.push("given_name".to_string());
+ params.push(given_name.to_string());
+ }
+
+ if let Some(ref surname) = self.surname {
+ params.push("surname".to_string());
+ params.push(surname.to_string());
+ }
+
+ if let Some(ref role) = self.role {
+ params.push("role".to_string());
+ params.push(role.to_string());
+ }
+
+ if let Some(ref raw_affiliation) = self.raw_affiliation {
+ params.push("raw_affiliation".to_string());
+ params.push(raw_affiliation.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseContrib value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseContrib {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub index: Vec<i64>,
+ pub creator_id: Vec<String>,
+ pub creator: Vec<models::CreatorEntity>,
+ pub raw_name: Vec<String>,
+ pub given_name: Vec<String>,
+ pub surname: Vec<String>,
+ pub role: Vec<String>,
+ pub raw_affiliation: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ReleaseContrib".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "index" => intermediate_rep
+ .index
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "creator_id" => intermediate_rep
+ .creator_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "creator" => intermediate_rep
+ .creator
+ .push(models::CreatorEntity::from_str(val).map_err(|x| format!("{}", x))?),
+ "raw_name" => intermediate_rep
+ .raw_name
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "given_name" => intermediate_rep
+ .given_name
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "surname" => intermediate_rep
+ .surname
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "role" => intermediate_rep
+ .role
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "raw_affiliation" => intermediate_rep
+ .raw_affiliation
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseContrib"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ReleaseContrib".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ReleaseContrib {
+ index: intermediate_rep.index.into_iter().next(),
+ creator_id: intermediate_rep.creator_id.into_iter().next(),
+ creator: intermediate_rep.creator.into_iter().next(),
+ raw_name: intermediate_rep.raw_name.into_iter().next(),
+ given_name: intermediate_rep.given_name.into_iter().next(),
+ surname: intermediate_rep.surname.into_iter().next(),
+ role: intermediate_rep.role.into_iter().next(),
+ raw_affiliation: intermediate_rep.raw_affiliation.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseEntity>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ReleaseEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ReleaseEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseEntity> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ReleaseEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ReleaseEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Required for valid entities. The title used in citations and for display. Sometimes the English translation of title e even if release content is not English.
+ #[serde(rename = "title")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub title: Option<String>,
+
+ /// Subtitle of release. In many cases, better to merge with title than include as separate field (unless combined title would be very long). See guide for details.
+ #[serde(rename = "subtitle")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub subtitle: Option<String>,
+
+ /// Title in original language if `title` field has been translated. See guide for details.
+ #[serde(rename = "original_title")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub original_title: Option<String>,
+
+ /// Identifier of work this release is part of. In creation (POST) requests, a work entity will be created automatically if this field is not set.
+ #[serde(rename = "work_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub work_id: Option<String>,
+
+ #[serde(rename = "container")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub container: Option<models::ContainerEntity>,
+
+ /// Complete file entities identified by `file_ids` field. Only included in GET responses when `files` included in `expand` parameter; ignored in PUT or POST requests.
+ #[serde(rename = "files")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub files: Option<Vec<models::FileEntity>>,
+
+ /// Complete file entities identified by `filesets_ids` field. Only included in GET responses when `filesets` included in `expand` parameter; ignored in PUT or POST requests.
+ #[serde(rename = "filesets")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub filesets: Option<Vec<models::FilesetEntity>>,
+
+ /// Complete webcapture entities identified by `webcapture_ids` field. Only included in GET responses when `webcaptures` included in `expand` parameter; ignored in PUT or POST requests.
+ #[serde(rename = "webcaptures")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub webcaptures: Option<Vec<models::WebcaptureEntity>>,
+
+ /// Used to link this release to a container entity that the release was published as part of.
+ #[serde(rename = "container_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub container_id: Option<String>,
+
+ /// \"Type\" or \"medium\" that this release is published as. See guide for valid values.
+ #[serde(rename = "release_type")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_type: Option<String>,
+
+ /// The stage of publication of this specific release. See guide for valid values and semantics.
+ #[serde(rename = "release_stage")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_stage: Option<String>,
+
+ /// Full date when this release was formally published. ISO format, like `2019-03-05`. See guide for semantics.
+ #[serde(rename = "release_date")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_date: Option<chrono::NaiveDate>,
+
+ /// Year when this release was formally published. Must match `release_date` if that field is set; this field exists because sometimes only the year is known.
+ #[serde(rename = "release_year")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_year: Option<i64>,
+
+ /// Type of withdrawl or retraction of this release, if applicable. If release has not been withdrawn, should be `null` (aka, not set, not the string \"null\" or an empty string).
+ #[serde(rename = "withdrawn_status")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub withdrawn_status: Option<String>,
+
+ /// Full date when this release was formally withdrawn (if applicable). ISO format, like `release_date`.
+ #[serde(rename = "withdrawn_date")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub withdrawn_date: Option<chrono::NaiveDate>,
+
+ /// Year corresponding with `withdrawn_date` like `release_year`/`release_date`.
+ #[serde(rename = "withdrawn_year")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub withdrawn_year: Option<i64>,
+
+ #[serde(rename = "ext_ids")]
+ pub ext_ids: models::ReleaseExtIds,
+
+ /// Volume number of container that this release was published in. Often corresponds to the \"Nth\" year of publication, but can be any string. See guide.
+ #[serde(rename = "volume")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub volume: Option<String>,
+
+ /// Issue number of volume/container that this release was published in. Sometimes coresponds to a month number in the year, but can be any string. See guide.
+ #[serde(rename = "issue")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub issue: Option<String>,
+
+ /// Either a single page number (\"first page\") or a range of pages separated by a dash (\"-\"). See guide for details.
+ #[serde(rename = "pages")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub pages: Option<String>,
+
+ /// For, eg, technical reports, which are published in series or assigned some other institutional or container-specific identifier.
+ #[serde(rename = "number")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub number: Option<String>,
+
+ /// For, eg, updated technical reports or software packages, where the version string may be the only field disambiguating between releases.
+ #[serde(rename = "version")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub version: Option<String>,
+
+ /// Name, usually English, of the entity or institution responsible for publication of this release. Not necessarily the imprint/brand. See guide.
+ #[serde(rename = "publisher")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub publisher: Option<String>,
+
+ /// Primary language of the content of the full release. Two-letter RFC1766/ISO639-1 language code, with some custom extensions/additions. See guide.
+ #[serde(rename = "language")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub language: Option<String>,
+
+ /// Short string (slug) name of license under which release is openly published (if applicable).
+ #[serde(rename = "license_slug")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub license_slug: Option<String>,
+
+ #[serde(rename = "contribs")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub contribs: Option<Vec<models::ReleaseContrib>>,
+
+ #[serde(rename = "refs")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub refs: Option<Vec<models::ReleaseRef>>,
+
+ #[serde(rename = "abstracts")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub abstracts: Option<Vec<models::ReleaseAbstract>>,
+}
+
+impl ReleaseEntity {
+ pub fn new(ext_ids: models::ReleaseExtIds) -> ReleaseEntity {
+ ReleaseEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ title: None,
+ subtitle: None,
+ original_title: None,
+ work_id: None,
+ container: None,
+ files: None,
+ filesets: None,
+ webcaptures: None,
+ container_id: None,
+ release_type: None,
+ release_stage: None,
+ release_date: None,
+ release_year: None,
+ withdrawn_status: None,
+ withdrawn_date: None,
+ withdrawn_year: None,
+ ext_ids: ext_ids,
+ volume: None,
+ issue: None,
+ pages: None,
+ number: None,
+ version: None,
+ publisher: None,
+ language: None,
+ license_slug: None,
+ contribs: None,
+ refs: None,
+ abstracts: None,
+ }
+ }
+}
+
+/// Converts the ReleaseEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ if let Some(ref title) = self.title {
+ params.push("title".to_string());
+ params.push(title.to_string());
+ }
+
+ if let Some(ref subtitle) = self.subtitle {
+ params.push("subtitle".to_string());
+ params.push(subtitle.to_string());
+ }
+
+ if let Some(ref original_title) = self.original_title {
+ params.push("original_title".to_string());
+ params.push(original_title.to_string());
+ }
+
+ if let Some(ref work_id) = self.work_id {
+ params.push("work_id".to_string());
+ params.push(work_id.to_string());
+ }
+
+ // Skipping container in query parameter serialization
+
+ // Skipping files in query parameter serialization
+
+ // Skipping filesets in query parameter serialization
+
+ // Skipping webcaptures in query parameter serialization
+
+ if let Some(ref container_id) = self.container_id {
+ params.push("container_id".to_string());
+ params.push(container_id.to_string());
+ }
+
+ if let Some(ref release_type) = self.release_type {
+ params.push("release_type".to_string());
+ params.push(release_type.to_string());
+ }
+
+ if let Some(ref release_stage) = self.release_stage {
+ params.push("release_stage".to_string());
+ params.push(release_stage.to_string());
+ }
+
+ // Skipping release_date in query parameter serialization
+
+ if let Some(ref release_year) = self.release_year {
+ params.push("release_year".to_string());
+ params.push(release_year.to_string());
+ }
+
+ if let Some(ref withdrawn_status) = self.withdrawn_status {
+ params.push("withdrawn_status".to_string());
+ params.push(withdrawn_status.to_string());
+ }
+
+ // Skipping withdrawn_date in query parameter serialization
+
+ if let Some(ref withdrawn_year) = self.withdrawn_year {
+ params.push("withdrawn_year".to_string());
+ params.push(withdrawn_year.to_string());
+ }
+
+ // Skipping ext_ids in query parameter serialization
+
+ if let Some(ref volume) = self.volume {
+ params.push("volume".to_string());
+ params.push(volume.to_string());
+ }
+
+ if let Some(ref issue) = self.issue {
+ params.push("issue".to_string());
+ params.push(issue.to_string());
+ }
+
+ if let Some(ref pages) = self.pages {
+ params.push("pages".to_string());
+ params.push(pages.to_string());
+ }
+
+ if let Some(ref number) = self.number {
+ params.push("number".to_string());
+ params.push(number.to_string());
+ }
+
+ if let Some(ref version) = self.version {
+ params.push("version".to_string());
+ params.push(version.to_string());
+ }
+
+ if let Some(ref publisher) = self.publisher {
+ params.push("publisher".to_string());
+ params.push(publisher.to_string());
+ }
+
+ if let Some(ref language) = self.language {
+ params.push("language".to_string());
+ params.push(language.to_string());
+ }
+
+ if let Some(ref license_slug) = self.license_slug {
+ params.push("license_slug".to_string());
+ params.push(license_slug.to_string());
+ }
+
+ // Skipping contribs in query parameter serialization
+
+ // Skipping refs in query parameter serialization
+
+ // Skipping abstracts in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub title: Vec<String>,
+ pub subtitle: Vec<String>,
+ pub original_title: Vec<String>,
+ pub work_id: Vec<String>,
+ pub container: Vec<models::ContainerEntity>,
+ pub files: Vec<Vec<models::FileEntity>>,
+ pub filesets: Vec<Vec<models::FilesetEntity>>,
+ pub webcaptures: Vec<Vec<models::WebcaptureEntity>>,
+ pub container_id: Vec<String>,
+ pub release_type: Vec<String>,
+ pub release_stage: Vec<String>,
+ pub release_date: Vec<chrono::NaiveDate>,
+ pub release_year: Vec<i64>,
+ pub withdrawn_status: Vec<String>,
+ pub withdrawn_date: Vec<chrono::NaiveDate>,
+ pub withdrawn_year: Vec<i64>,
+ pub ext_ids: Vec<models::ReleaseExtIds>,
+ pub volume: Vec<String>,
+ pub issue: Vec<String>,
+ pub pages: Vec<String>,
+ pub number: Vec<String>,
+ pub version: Vec<String>,
+ pub publisher: Vec<String>,
+ pub language: Vec<String>,
+ pub license_slug: Vec<String>,
+ pub contribs: Vec<Vec<models::ReleaseContrib>>,
+ pub refs: Vec<Vec<models::ReleaseRef>>,
+ pub abstracts: Vec<Vec<models::ReleaseAbstract>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ReleaseEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "edit_extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "title" => intermediate_rep
+ .title
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "subtitle" => intermediate_rep
+ .subtitle
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "original_title" => intermediate_rep
+ .original_title
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "work_id" => intermediate_rep
+ .work_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "container" => intermediate_rep.container.push(
+ models::ContainerEntity::from_str(val).map_err(|x| format!("{}", x))?,
+ ),
+ "files" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "filesets" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "webcaptures" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "container_id" => intermediate_rep
+ .container_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "release_type" => intermediate_rep
+ .release_type
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "release_stage" => intermediate_rep
+ .release_stage
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "release_date" => intermediate_rep
+ .release_date
+ .push(chrono::NaiveDate::from_str(val).map_err(|x| format!("{}", x))?),
+ "release_year" => intermediate_rep
+ .release_year
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "withdrawn_status" => intermediate_rep
+ .withdrawn_status
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "withdrawn_date" => intermediate_rep
+ .withdrawn_date
+ .push(chrono::NaiveDate::from_str(val).map_err(|x| format!("{}", x))?),
+ "withdrawn_year" => intermediate_rep
+ .withdrawn_year
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "ext_ids" => intermediate_rep
+ .ext_ids
+ .push(models::ReleaseExtIds::from_str(val).map_err(|x| format!("{}", x))?),
+ "volume" => intermediate_rep
+ .volume
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "issue" => intermediate_rep
+ .issue
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "pages" => intermediate_rep
+ .pages
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "number" => intermediate_rep
+ .number
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "version" => intermediate_rep
+ .version
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "publisher" => intermediate_rep
+ .publisher
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "language" => intermediate_rep
+ .language
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "license_slug" => intermediate_rep
+ .license_slug
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "contribs" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "refs" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ "abstracts" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseEntity"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ReleaseEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ReleaseEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ title: intermediate_rep.title.into_iter().next(),
+ subtitle: intermediate_rep.subtitle.into_iter().next(),
+ original_title: intermediate_rep.original_title.into_iter().next(),
+ work_id: intermediate_rep.work_id.into_iter().next(),
+ container: intermediate_rep.container.into_iter().next(),
+ files: intermediate_rep.files.into_iter().next(),
+ filesets: intermediate_rep.filesets.into_iter().next(),
+ webcaptures: intermediate_rep.webcaptures.into_iter().next(),
+ container_id: intermediate_rep.container_id.into_iter().next(),
+ release_type: intermediate_rep.release_type.into_iter().next(),
+ release_stage: intermediate_rep.release_stage.into_iter().next(),
+ release_date: intermediate_rep.release_date.into_iter().next(),
+ release_year: intermediate_rep.release_year.into_iter().next(),
+ withdrawn_status: intermediate_rep.withdrawn_status.into_iter().next(),
+ withdrawn_date: intermediate_rep.withdrawn_date.into_iter().next(),
+ withdrawn_year: intermediate_rep.withdrawn_year.into_iter().next(),
+ ext_ids: intermediate_rep
+ .ext_ids
+ .into_iter()
+ .next()
+ .ok_or("ext_ids missing in ReleaseEntity".to_string())?,
+ volume: intermediate_rep.volume.into_iter().next(),
+ issue: intermediate_rep.issue.into_iter().next(),
+ pages: intermediate_rep.pages.into_iter().next(),
+ number: intermediate_rep.number.into_iter().next(),
+ version: intermediate_rep.version.into_iter().next(),
+ publisher: intermediate_rep.publisher.into_iter().next(),
+ language: intermediate_rep.language.into_iter().next(),
+ license_slug: intermediate_rep.license_slug.into_iter().next(),
+ contribs: intermediate_rep.contribs.into_iter().next(),
+ refs: intermediate_rep.refs.into_iter().next(),
+ abstracts: intermediate_rep.abstracts.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseExtIds> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseExtIds>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ReleaseExtIds>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ReleaseExtIds - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseExtIds> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ReleaseExtIds as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ReleaseExtIds - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseExtIds {
+ /// Digital Object Identifier (DOI), mostly for published papers and datasets. Should be registered and resolvable via https://doi.org/
+ #[serde(rename = "doi")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub doi: Option<String>,
+
+ /// Wikidata entity QID
+ #[serde(rename = "wikidata_qid")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub wikidata_qid: Option<String>,
+
+ /// ISBN-13, for books. Usually not set for chapters. ISBN-10 should be converted to ISBN-13.
+ #[serde(rename = "isbn13")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub isbn13: Option<String>,
+
+ /// PubMed Identifier
+ #[serde(rename = "pmid")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub pmid: Option<String>,
+
+ /// PubMed Central Identifier
+ #[serde(rename = "pmcid")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub pmcid: Option<String>,
+
+ /// CORE (https://core.ac.uk) identifier
+ #[serde(rename = "core")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub core: Option<String>,
+
+ /// arXiv (https://arxiv.org) identifier; must include version
+ #[serde(rename = "arxiv")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub arxiv: Option<String>,
+
+ /// JSTOR work identifier
+ #[serde(rename = "jstor")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub jstor: Option<String>,
+
+ /// ARK identifier
+ #[serde(rename = "ark")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ark: Option<String>,
+
+ /// Microsoft Academic Graph identifier
+ #[serde(rename = "mag")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub mag: Option<String>,
+
+ /// DOAJ article-level identifier
+ #[serde(rename = "doaj")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub doaj: Option<String>,
+
+ /// dblp (https://dblp.uni-trier.de/) paper identifier; eg for conference proceedings
+ #[serde(rename = "dblp")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub dblp: Option<String>,
+
+ /// OAI-PMH identifier; only used when an OAI-PMH record is the only authoritative metadata (eg, journal OAI-PMH feeds w/o DOIs)
+ #[serde(rename = "oai")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub oai: Option<String>,
+}
+
+impl ReleaseExtIds {
+ pub fn new() -> ReleaseExtIds {
+ ReleaseExtIds {
+ doi: None,
+ wikidata_qid: None,
+ isbn13: None,
+ pmid: None,
+ pmcid: None,
+ core: None,
+ arxiv: None,
+ jstor: None,
+ ark: None,
+ mag: None,
+ doaj: None,
+ dblp: None,
+ oai: None,
+ }
+ }
+}
+
+/// Converts the ReleaseExtIds value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseExtIds {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref doi) = self.doi {
+ params.push("doi".to_string());
+ params.push(doi.to_string());
+ }
+
+ if let Some(ref wikidata_qid) = self.wikidata_qid {
+ params.push("wikidata_qid".to_string());
+ params.push(wikidata_qid.to_string());
+ }
+
+ if let Some(ref isbn13) = self.isbn13 {
+ params.push("isbn13".to_string());
+ params.push(isbn13.to_string());
+ }
+
+ if let Some(ref pmid) = self.pmid {
+ params.push("pmid".to_string());
+ params.push(pmid.to_string());
+ }
+
+ if let Some(ref pmcid) = self.pmcid {
+ params.push("pmcid".to_string());
+ params.push(pmcid.to_string());
+ }
+
+ if let Some(ref core) = self.core {
+ params.push("core".to_string());
+ params.push(core.to_string());
+ }
+
+ if let Some(ref arxiv) = self.arxiv {
+ params.push("arxiv".to_string());
+ params.push(arxiv.to_string());
+ }
+
+ if let Some(ref jstor) = self.jstor {
+ params.push("jstor".to_string());
+ params.push(jstor.to_string());
+ }
+
+ if let Some(ref ark) = self.ark {
+ params.push("ark".to_string());
+ params.push(ark.to_string());
+ }
+
+ if let Some(ref mag) = self.mag {
+ params.push("mag".to_string());
+ params.push(mag.to_string());
+ }
+
+ if let Some(ref doaj) = self.doaj {
+ params.push("doaj".to_string());
+ params.push(doaj.to_string());
+ }
+
+ if let Some(ref dblp) = self.dblp {
+ params.push("dblp".to_string());
+ params.push(dblp.to_string());
+ }
+
+ if let Some(ref oai) = self.oai {
+ params.push("oai".to_string());
+ params.push(oai.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseExtIds value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseExtIds {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub doi: Vec<String>,
+ pub wikidata_qid: Vec<String>,
+ pub isbn13: Vec<String>,
+ pub pmid: Vec<String>,
+ pub pmcid: Vec<String>,
+ pub core: Vec<String>,
+ pub arxiv: Vec<String>,
+ pub jstor: Vec<String>,
+ pub ark: Vec<String>,
+ pub mag: Vec<String>,
+ pub doaj: Vec<String>,
+ pub dblp: Vec<String>,
+ pub oai: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ReleaseExtIds".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "doi" => intermediate_rep
+ .doi
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "wikidata_qid" => intermediate_rep
+ .wikidata_qid
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "isbn13" => intermediate_rep
+ .isbn13
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "pmid" => intermediate_rep
+ .pmid
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "pmcid" => intermediate_rep
+ .pmcid
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "core" => intermediate_rep
+ .core
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "arxiv" => intermediate_rep
+ .arxiv
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "jstor" => intermediate_rep
+ .jstor
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ark" => intermediate_rep
+ .ark
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "mag" => intermediate_rep
+ .mag
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "doaj" => intermediate_rep
+ .doaj
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "dblp" => intermediate_rep
+ .dblp
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "oai" => intermediate_rep
+ .oai
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ReleaseExtIds".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ReleaseExtIds {
+ doi: intermediate_rep.doi.into_iter().next(),
+ wikidata_qid: intermediate_rep.wikidata_qid.into_iter().next(),
+ isbn13: intermediate_rep.isbn13.into_iter().next(),
+ pmid: intermediate_rep.pmid.into_iter().next(),
+ pmcid: intermediate_rep.pmcid.into_iter().next(),
+ core: intermediate_rep.core.into_iter().next(),
+ arxiv: intermediate_rep.arxiv.into_iter().next(),
+ jstor: intermediate_rep.jstor.into_iter().next(),
+ ark: intermediate_rep.ark.into_iter().next(),
+ mag: intermediate_rep.mag.into_iter().next(),
+ doaj: intermediate_rep.doaj.into_iter().next(),
+ dblp: intermediate_rep.dblp.into_iter().next(),
+ oai: intermediate_rep.oai.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<ReleaseRef> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<ReleaseRef>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<ReleaseRef>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for ReleaseRef - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ReleaseRef> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <ReleaseRef as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into ReleaseRef - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct ReleaseRef {
+ /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`.
+ #[serde(rename = "index")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub index: Option<i64>,
+
+ /// Optional, fatcat identifier of release entity that this reference is citing.
+ #[serde(rename = "target_release_id")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub target_release_id: Option<String>,
+
+ /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field.
+ #[serde(rename = "key")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub key: Option<String>,
+
+ /// Year that the cited work was published in.
+ #[serde(rename = "year")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub year: Option<i64>,
+
+ /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name.
+ #[serde(rename = "container_name")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub container_name: Option<String>,
+
+ /// Name of the work being cited.
+ #[serde(rename = "title")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub title: Option<String>,
+
+ /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited.
+ #[serde(rename = "locator")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub locator: Option<String>,
+}
+
+impl ReleaseRef {
+ pub fn new() -> ReleaseRef {
+ ReleaseRef {
+ index: None,
+ target_release_id: None,
+ extra: None,
+ key: None,
+ year: None,
+ container_name: None,
+ title: None,
+ locator: None,
+ }
+ }
+}
+
+/// Converts the ReleaseRef value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for ReleaseRef {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref index) = self.index {
+ params.push("index".to_string());
+ params.push(index.to_string());
+ }
+
+ if let Some(ref target_release_id) = self.target_release_id {
+ params.push("target_release_id".to_string());
+ params.push(target_release_id.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ if let Some(ref key) = self.key {
+ params.push("key".to_string());
+ params.push(key.to_string());
+ }
+
+ if let Some(ref year) = self.year {
+ params.push("year".to_string());
+ params.push(year.to_string());
+ }
+
+ if let Some(ref container_name) = self.container_name {
+ params.push("container_name".to_string());
+ params.push(container_name.to_string());
+ }
+
+ if let Some(ref title) = self.title {
+ params.push("title".to_string());
+ params.push(title.to_string());
+ }
+
+ if let Some(ref locator) = self.locator {
+ params.push("locator".to_string());
+ params.push(locator.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a ReleaseRef value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for ReleaseRef {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub index: Vec<i64>,
+ pub target_release_id: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub key: Vec<String>,
+ pub year: Vec<i64>,
+ pub container_name: Vec<String>,
+ pub title: Vec<String>,
+ pub locator: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing ReleaseRef".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "index" => intermediate_rep
+ .index
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "target_release_id" => intermediate_rep
+ .target_release_id
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in ReleaseRef"
+ .to_string(),
+ )
+ }
+ "key" => intermediate_rep
+ .key
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "year" => intermediate_rep
+ .year
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "container_name" => intermediate_rep
+ .container_name
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "title" => intermediate_rep
+ .title
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "locator" => intermediate_rep
+ .locator
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing ReleaseRef".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(ReleaseRef {
+ index: intermediate_rep.index.into_iter().next(),
+ target_release_id: intermediate_rep.target_release_id.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ key: intermediate_rep.key.into_iter().next(),
+ year: intermediate_rep.year.into_iter().next(),
+ container_name: intermediate_rep.container_name.into_iter().next(),
+ title: intermediate_rep.title.into_iter().next(),
+ locator: intermediate_rep.locator.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<Success> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<Success>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<Success>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for Success - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Success> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <Success as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into Success - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct Success {
+ #[serde(rename = "success")]
+ pub success: bool,
+
+ #[serde(rename = "message")]
+ pub message: String,
+}
+
+impl Success {
+ pub fn new(success: bool, message: String) -> Success {
+ Success {
+ success: success,
+ message: message,
+ }
+ }
+}
+
+/// Converts the Success value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for Success {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("success".to_string());
+ params.push(self.success.to_string());
+
+ params.push("message".to_string());
+ params.push(self.message.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a Success value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for Success {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub success: Vec<bool>,
+ pub message: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing Success".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "success" => intermediate_rep
+ .success
+ .push(bool::from_str(val).map_err(|x| format!("{}", x))?),
+ "message" => intermediate_rep
+ .message
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing Success".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(Success {
+ success: intermediate_rep
+ .success
+ .into_iter()
+ .next()
+ .ok_or("success missing in Success".to_string())?,
+ message: intermediate_rep
+ .message
+ .into_iter()
+ .next()
+ .ok_or("message missing in Success".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureAutoBatch>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<WebcaptureAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for WebcaptureAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<WebcaptureAutoBatch>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <WebcaptureAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into WebcaptureAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::WebcaptureEntity>,
+}
+
+impl WebcaptureAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::WebcaptureEntity>,
+ ) -> WebcaptureAutoBatch {
+ WebcaptureAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the WebcaptureAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::WebcaptureEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing WebcaptureAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureAutoBatch"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing WebcaptureAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(WebcaptureAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in WebcaptureAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in WebcaptureAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureCdxLine> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureCdxLine>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<WebcaptureCdxLine>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for WebcaptureCdxLine - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<WebcaptureCdxLine>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <WebcaptureCdxLine as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into WebcaptureCdxLine - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureCdxLine {
+ /// \"Sortable URL\" format. See guide for details.
+ #[serde(rename = "surt")]
+ pub surt: String,
+
+ /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision.
+ #[serde(rename = "timestamp")]
+ pub timestamp: chrono::DateTime<chrono::Utc>,
+
+ /// Full URL/URI of resource captured.
+ #[serde(rename = "url")]
+ pub url: String,
+
+ /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type.
+ #[serde(rename = "mimetype")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub mimetype: Option<String>,
+
+ /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully.
+ #[serde(rename = "status_code")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub status_code: Option<i64>,
+
+ /// Resource (file) size in bytes
+ #[serde(rename = "size")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub size: Option<i64>,
+
+ /// SHA-1 hash of data, in hex encoding
+ #[serde(rename = "sha1")]
+ pub sha1: String,
+
+ /// SHA-256 hash of data, in hex encoding
+ #[serde(rename = "sha256")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub sha256: Option<String>,
+}
+
+impl WebcaptureCdxLine {
+ pub fn new(
+ surt: String,
+ timestamp: chrono::DateTime<chrono::Utc>,
+ url: String,
+ sha1: String,
+ ) -> WebcaptureCdxLine {
+ WebcaptureCdxLine {
+ surt: surt,
+ timestamp: timestamp,
+ url: url,
+ mimetype: None,
+ status_code: None,
+ size: None,
+ sha1: sha1,
+ sha256: None,
+ }
+ }
+}
+
+/// Converts the WebcaptureCdxLine value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureCdxLine {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("surt".to_string());
+ params.push(self.surt.to_string());
+
+ // Skipping timestamp in query parameter serialization
+
+ params.push("url".to_string());
+ params.push(self.url.to_string());
+
+ if let Some(ref mimetype) = self.mimetype {
+ params.push("mimetype".to_string());
+ params.push(mimetype.to_string());
+ }
+
+ if let Some(ref status_code) = self.status_code {
+ params.push("status_code".to_string());
+ params.push(status_code.to_string());
+ }
+
+ if let Some(ref size) = self.size {
+ params.push("size".to_string());
+ params.push(size.to_string());
+ }
+
+ params.push("sha1".to_string());
+ params.push(self.sha1.to_string());
+
+ if let Some(ref sha256) = self.sha256 {
+ params.push("sha256".to_string());
+ params.push(sha256.to_string());
+ }
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureCdxLine value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureCdxLine {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub surt: Vec<String>,
+ pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+ pub url: Vec<String>,
+ pub mimetype: Vec<String>,
+ pub status_code: Vec<i64>,
+ pub size: Vec<i64>,
+ pub sha1: Vec<String>,
+ pub sha256: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing WebcaptureCdxLine".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "surt" => intermediate_rep
+ .surt
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "timestamp" => intermediate_rep.timestamp.push(
+ chrono::DateTime::<chrono::Utc>::from_str(val)
+ .map_err(|x| format!("{}", x))?,
+ ),
+ "url" => intermediate_rep
+ .url
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "mimetype" => intermediate_rep
+ .mimetype
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "status_code" => intermediate_rep
+ .status_code
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "size" => intermediate_rep
+ .size
+ .push(i64::from_str(val).map_err(|x| format!("{}", x))?),
+ "sha1" => intermediate_rep
+ .sha1
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "sha256" => intermediate_rep
+ .sha256
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing WebcaptureCdxLine".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(WebcaptureCdxLine {
+ surt: intermediate_rep
+ .surt
+ .into_iter()
+ .next()
+ .ok_or("surt missing in WebcaptureCdxLine".to_string())?,
+ timestamp: intermediate_rep
+ .timestamp
+ .into_iter()
+ .next()
+ .ok_or("timestamp missing in WebcaptureCdxLine".to_string())?,
+ url: intermediate_rep
+ .url
+ .into_iter()
+ .next()
+ .ok_or("url missing in WebcaptureCdxLine".to_string())?,
+ mimetype: intermediate_rep.mimetype.into_iter().next(),
+ status_code: intermediate_rep.status_code.into_iter().next(),
+ size: intermediate_rep.size.into_iter().next(),
+ sha1: intermediate_rep
+ .sha1
+ .into_iter()
+ .next()
+ .ok_or("sha1 missing in WebcaptureCdxLine".to_string())?,
+ sha256: intermediate_rep.sha256.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureEntity>>
+ for hyper::header::HeaderValue
+{
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<WebcaptureEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for WebcaptureEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue>
+ for header::IntoHeaderValue<WebcaptureEntity>
+{
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <WebcaptureEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into WebcaptureEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ #[serde(rename = "cdx")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub cdx: Option<Vec<models::WebcaptureCdxLine>>,
+
+ #[serde(rename = "archive_urls")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub archive_urls: Option<Vec<models::WebcaptureUrl>>,
+
+ /// Base URL of the primary resource this is a capture of
+ #[serde(rename = "original_url")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub original_url: Option<String>,
+
+ /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL.
+ #[serde(rename = "timestamp")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub timestamp: Option<chrono::DateTime<chrono::Utc>>,
+
+ /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
+ #[serde(rename = "release_ids")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub release_ids: Option<Vec<String>>,
+
+ /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
+ #[serde(rename = "releases")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub releases: Option<Vec<models::ReleaseEntity>>,
+}
+
+impl WebcaptureEntity {
+ pub fn new() -> WebcaptureEntity {
+ WebcaptureEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ cdx: None,
+ archive_urls: None,
+ original_url: None,
+ timestamp: None,
+ release_ids: None,
+ releases: None,
+ }
+ }
+}
+
+/// Converts the WebcaptureEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ // Skipping cdx in query parameter serialization
+
+ // Skipping archive_urls in query parameter serialization
+
+ if let Some(ref original_url) = self.original_url {
+ params.push("original_url".to_string());
+ params.push(original_url.to_string());
+ }
+
+ // Skipping timestamp in query parameter serialization
+
+ if let Some(ref release_ids) = self.release_ids {
+ params.push("release_ids".to_string());
+ params.push(
+ release_ids
+ .iter()
+ .map(|x| x.to_string())
+ .collect::<Vec<_>>()
+ .join(",")
+ .to_string(),
+ );
+ }
+
+ // Skipping releases in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub cdx: Vec<Vec<models::WebcaptureCdxLine>>,
+ pub archive_urls: Vec<Vec<models::WebcaptureUrl>>,
+ pub original_url: Vec<String>,
+ pub timestamp: Vec<chrono::DateTime<chrono::Utc>>,
+ pub release_ids: Vec<Vec<String>>,
+ pub releases: Vec<Vec<models::ReleaseEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing WebcaptureEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureEntity"
+ .to_string(),
+ ),
+ "edit_extra" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureEntity"
+ .to_string(),
+ ),
+ "cdx" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureEntity"
+ .to_string(),
+ ),
+ "archive_urls" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureEntity"
+ .to_string(),
+ ),
+ "original_url" => intermediate_rep
+ .original_url
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "timestamp" => intermediate_rep.timestamp.push(
+ chrono::DateTime::<chrono::Utc>::from_str(val)
+ .map_err(|x| format!("{}", x))?,
+ ),
+ "release_ids" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureEntity"
+ .to_string(),
+ ),
+ "releases" => return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WebcaptureEntity"
+ .to_string(),
+ ),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing WebcaptureEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(WebcaptureEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ cdx: intermediate_rep.cdx.into_iter().next(),
+ archive_urls: intermediate_rep.archive_urls.into_iter().next(),
+ original_url: intermediate_rep.original_url.into_iter().next(),
+ timestamp: intermediate_rep.timestamp.into_iter().next(),
+ release_ids: intermediate_rep.release_ids.into_iter().next(),
+ releases: intermediate_rep.releases.into_iter().next(),
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<WebcaptureUrl> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WebcaptureUrl>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<WebcaptureUrl>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for WebcaptureUrl - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WebcaptureUrl> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <WebcaptureUrl as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into WebcaptureUrl - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WebcaptureUrl {
+ /// URL/URI pointing to archive of this web resource.
+ #[serde(rename = "url")]
+ pub url: String,
+
+ /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list.
+ #[serde(rename = "rel")]
+ pub rel: String,
+}
+
+impl WebcaptureUrl {
+ pub fn new(url: String, rel: String) -> WebcaptureUrl {
+ WebcaptureUrl { url: url, rel: rel }
+ }
+}
+
+/// Converts the WebcaptureUrl value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WebcaptureUrl {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ params.push("url".to_string());
+ params.push(self.url.to_string());
+
+ params.push("rel".to_string());
+ params.push(self.rel.to_string());
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WebcaptureUrl value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WebcaptureUrl {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub url: Vec<String>,
+ pub rel: Vec<String>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing WebcaptureUrl".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "url" => intermediate_rep
+ .url
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "rel" => intermediate_rep
+ .rel
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing WebcaptureUrl".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(WebcaptureUrl {
+ url: intermediate_rep
+ .url
+ .into_iter()
+ .next()
+ .ok_or("url missing in WebcaptureUrl".to_string())?,
+ rel: intermediate_rep
+ .rel
+ .into_iter()
+ .next()
+ .ok_or("rel missing in WebcaptureUrl".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<WorkAutoBatch> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WorkAutoBatch>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<WorkAutoBatch>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for WorkAutoBatch - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkAutoBatch> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <WorkAutoBatch as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into WorkAutoBatch - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WorkAutoBatch {
+ #[serde(rename = "editgroup")]
+ pub editgroup: models::Editgroup,
+
+ #[serde(rename = "entity_list")]
+ pub entity_list: Vec<models::WorkEntity>,
+}
+
+impl WorkAutoBatch {
+ pub fn new(
+ editgroup: models::Editgroup,
+ entity_list: Vec<models::WorkEntity>,
+ ) -> WorkAutoBatch {
+ WorkAutoBatch {
+ editgroup: editgroup,
+ entity_list: entity_list,
+ }
+ }
+}
+
+/// Converts the WorkAutoBatch value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WorkAutoBatch {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+ // Skipping editgroup in query parameter serialization
+
+ // Skipping entity_list in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WorkAutoBatch value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WorkAutoBatch {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub editgroup: Vec<models::Editgroup>,
+ pub entity_list: Vec<Vec<models::WorkEntity>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing WorkAutoBatch".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "editgroup" => intermediate_rep
+ .editgroup
+ .push(models::Editgroup::from_str(val).map_err(|x| format!("{}", x))?),
+ "entity_list" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WorkAutoBatch"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing WorkAutoBatch".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(WorkAutoBatch {
+ editgroup: intermediate_rep
+ .editgroup
+ .into_iter()
+ .next()
+ .ok_or("editgroup missing in WorkAutoBatch".to_string())?,
+ entity_list: intermediate_rep
+ .entity_list
+ .into_iter()
+ .next()
+ .ok_or("entity_list missing in WorkAutoBatch".to_string())?,
+ })
+ }
+}
+
+// Methods for converting between header::IntoHeaderValue<WorkEntity> and hyper::header::HeaderValue
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<header::IntoHeaderValue<WorkEntity>> for hyper::header::HeaderValue {
+ type Error = String;
+
+ fn try_from(
+ hdr_value: header::IntoHeaderValue<WorkEntity>,
+ ) -> std::result::Result<Self, Self::Error> {
+ let hdr_value = hdr_value.to_string();
+ match hyper::header::HeaderValue::from_str(&hdr_value) {
+ std::result::Result::Ok(value) => std::result::Result::Ok(value),
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Invalid header value for WorkEntity - value: {} is invalid {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[cfg(any(feature = "client", feature = "server"))]
+impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<WorkEntity> {
+ type Error = String;
+
+ fn try_from(hdr_value: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
+ match hdr_value.to_str() {
+ std::result::Result::Ok(value) => {
+ match <WorkEntity as std::str::FromStr>::from_str(value) {
+ std::result::Result::Ok(value) => {
+ std::result::Result::Ok(header::IntoHeaderValue(value))
+ }
+ std::result::Result::Err(err) => std::result::Result::Err(format!(
+ "Unable to convert header value '{}' into WorkEntity - {}",
+ value, err
+ )),
+ }
+ }
+ std::result::Result::Err(e) => std::result::Result::Err(format!(
+ "Unable to convert header: {:?} to string: {}",
+ hdr_value, e
+ )),
+ }
+ }
+}
+
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
+pub struct WorkEntity {
+ // Note: inline enums are not fully supported by openapi-generator
+ #[serde(rename = "state")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub state: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "ident")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub ident: Option<String>,
+
+ /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
+ #[serde(rename = "revision")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub revision: Option<String>,
+
+ /// base32-encoded unique identifier
+ #[serde(rename = "redirect")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub redirect: Option<String>,
+
+ /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
+ #[serde(rename = "extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+
+ /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
+ #[serde(rename = "edit_extra")]
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub edit_extra: Option<std::collections::HashMap<String, serde_json::Value>>,
+}
+
+impl WorkEntity {
+ pub fn new() -> WorkEntity {
+ WorkEntity {
+ state: None,
+ ident: None,
+ revision: None,
+ redirect: None,
+ extra: None,
+ edit_extra: None,
+ }
+ }
+}
+
+/// Converts the WorkEntity value to the Query Parameters representation (style=form, explode=false)
+/// specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde serializer
+impl std::string::ToString for WorkEntity {
+ fn to_string(&self) -> String {
+ let mut params: Vec<String> = vec![];
+
+ if let Some(ref state) = self.state {
+ params.push("state".to_string());
+ params.push(state.to_string());
+ }
+
+ if let Some(ref ident) = self.ident {
+ params.push("ident".to_string());
+ params.push(ident.to_string());
+ }
+
+ if let Some(ref revision) = self.revision {
+ params.push("revision".to_string());
+ params.push(revision.to_string());
+ }
+
+ if let Some(ref redirect) = self.redirect {
+ params.push("redirect".to_string());
+ params.push(redirect.to_string());
+ }
+
+ // Skipping extra in query parameter serialization
+ // Skipping extra in query parameter serialization
+
+ // Skipping edit_extra in query parameter serialization
+ // Skipping edit_extra in query parameter serialization
+
+ params.join(",").to_string()
+ }
+}
+
+/// Converts Query Parameters representation (style=form, explode=false) to a WorkEntity value
+/// as specified in https://swagger.io/docs/specification/serialization/
+/// Should be implemented in a serde deserializer
+impl std::str::FromStr for WorkEntity {
+ type Err = String;
+
+ fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+ #[derive(Default)]
+ // An intermediate representation of the struct to use for parsing.
+ struct IntermediateRep {
+ pub state: Vec<String>,
+ pub ident: Vec<String>,
+ pub revision: Vec<String>,
+ pub redirect: Vec<String>,
+ pub extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ pub edit_extra: Vec<std::collections::HashMap<String, serde_json::Value>>,
+ }
+
+ let mut intermediate_rep = IntermediateRep::default();
+
+ // Parse into intermediate representation
+ let mut string_iter = s.split(',').into_iter();
+ let mut key_result = string_iter.next();
+
+ while key_result.is_some() {
+ let val = match string_iter.next() {
+ Some(x) => x,
+ None => {
+ return std::result::Result::Err(
+ "Missing value while parsing WorkEntity".to_string(),
+ )
+ }
+ };
+
+ if let Some(key) = key_result {
+ match key {
+ "state" => intermediate_rep
+ .state
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "ident" => intermediate_rep
+ .ident
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "revision" => intermediate_rep
+ .revision
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "redirect" => intermediate_rep
+ .redirect
+ .push(String::from_str(val).map_err(|x| format!("{}", x))?),
+ "extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WorkEntity"
+ .to_string(),
+ )
+ }
+ "edit_extra" => {
+ return std::result::Result::Err(
+ "Parsing a container in this style is not supported in WorkEntity"
+ .to_string(),
+ )
+ }
+ _ => {
+ return std::result::Result::Err(
+ "Unexpected key while parsing WorkEntity".to_string(),
+ )
+ }
+ }
+ }
+
+ // Get the next key
+ key_result = string_iter.next();
+ }
+
+ // Use the intermediate representation to return the struct
+ std::result::Result::Ok(WorkEntity {
+ state: intermediate_rep.state.into_iter().next(),
+ ident: intermediate_rep.ident.into_iter().next(),
+ revision: intermediate_rep.revision.into_iter().next(),
+ redirect: intermediate_rep.redirect.into_iter().next(),
+ extra: intermediate_rep.extra.into_iter().next(),
+ edit_extra: intermediate_rep.edit_extra.into_iter().next(),
+ })
+ }
+}