r1_api_layer/

models.rs

#![allow(unused_qualifications)]

use validator::Validate;

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

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Click {
    #[serde(rename = "Point")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub point: Option<models::Point>,

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

impl Click {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Click {
        Click {
            point: None,
            time: None,
        }
    }
}

/// Converts the Click 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 Click {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            // Skipping non-primitive type Point in query parameter serialization
            self.time
                .as_ref()
                .map(|time| ["time".to_string(), time.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 Click".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "Point" => intermediate_rep.point.push(
                        <models::Point as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "time" => intermediate_rep.time.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Click".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Click {
            point: intermediate_rep.point.into_iter().next(),
            time: intermediate_rep.time.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<Click>,
    ) -> 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 Click - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Click> {
    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 <Click 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 Click - {}",
                    value, err
                )),
            },
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<Click>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<Click> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <Click as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into Click - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct CreateUserDto {
    #[serde(rename = "UUID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uuid: Option<String>,

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

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

impl CreateUserDto {
    #[allow(clippy::new_without_default)]
    pub fn new() -> CreateUserDto {
        CreateUserDto {
            uuid: None,
            user_name: None,
            profile_picture: None,
        }
    }
}

/// Converts the CreateUserDto 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 CreateUserDto {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            self.uuid
                .as_ref()
                .map(|uuid| ["UUID".to_string(), uuid.to_string()].join(",")),
            self.user_name
                .as_ref()
                .map(|user_name| ["userName".to_string(), user_name.to_string()].join(",")),
            self.profile_picture.as_ref().map(|profile_picture| {
                ["profilePicture".to_string(), profile_picture.to_string()].join(",")
            }),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 CreateUserDto".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "UUID" => intermediate_rep.uuid.push(
                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "userName" => intermediate_rep.user_name.push(
                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "profilePicture" => intermediate_rep.profile_picture.push(
                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing CreateUserDto".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(CreateUserDto {
            uuid: intermediate_rep.uuid.into_iter().next(),
            user_name: intermediate_rep.user_name.into_iter().next(),
            profile_picture: intermediate_rep.profile_picture.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<CreateUserDto>,
    ) -> 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 CreateUserDto - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<CreateUserDto> {
    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 <CreateUserDto 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 CreateUserDto - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<CreateUserDto>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<CreateUserDto> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <CreateUserDto as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into CreateUserDto - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct GameEndDto {
    #[serde(rename = "UUID")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uuid: Option<uuid::Uuid>,

    #[serde(rename = "GameTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub game_time: Option<i32>,

    #[serde(rename = "SpawnPoints")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spawn_points: Option<Vec<models::Spawn>>,

    #[serde(rename = "ClickPoints")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub click_points: Option<Vec<models::Click>>,

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

impl GameEndDto {
    #[allow(clippy::new_without_default)]
    pub fn new() -> GameEndDto {
        GameEndDto {
            uuid: None,
            game_time: None,
            spawn_points: None,
            click_points: None,
            difficulty: None,
        }
    }
}

/// Converts the GameEndDto 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 GameEndDto {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            // Skipping non-primitive type UUID in query parameter serialization
            self.game_time
                .as_ref()
                .map(|game_time| ["GameTime".to_string(), game_time.to_string()].join(",")),
            // Skipping non-primitive type SpawnPoints in query parameter serialization
            // Skipping non-primitive type ClickPoints in query parameter serialization
            // Skipping non-primitive type difficulty in query parameter serialization
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        /// An intermediate representation of the struct to use for parsing.
        #[derive(Default)]
        #[allow(dead_code)]
        struct IntermediateRep {
            pub uuid: Vec<uuid::Uuid>,
            pub game_time: Vec<i32>,
            pub spawn_points: Vec<Vec<models::Spawn>>,
            pub click_points: Vec<Vec<models::Click>>,
            pub difficulty: Vec<models::GameEndDtoDifficulty>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 GameEndDto".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "UUID" => intermediate_rep.uuid.push(
                        <uuid::Uuid as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "GameTime" => intermediate_rep.game_time.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    "SpawnPoints" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in GameEndDto"
                                .to_string(),
                        )
                    }
                    "ClickPoints" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in GameEndDto"
                                .to_string(),
                        )
                    }
                    #[allow(clippy::redundant_clone)]
                    "difficulty" => intermediate_rep.difficulty.push(
                        <models::GameEndDtoDifficulty as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing GameEndDto".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(GameEndDto {
            uuid: intermediate_rep.uuid.into_iter().next(),
            game_time: intermediate_rep.game_time.into_iter().next(),
            spawn_points: intermediate_rep.spawn_points.into_iter().next(),
            click_points: intermediate_rep.click_points.into_iter().next(),
            difficulty: intermediate_rep.difficulty.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<GameEndDto>,
    ) -> 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 GameEndDto - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<GameEndDto> {
    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 <GameEndDto 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 GameEndDto - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<GameEndDto>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<GameEndDto> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <GameEndDto as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into GameEndDto - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

/// Enumeration of values.
/// Since this enum's variants do not hold data, we can easily define them as `#[repr(C)]`
/// which helps with FFI.
#[allow(non_camel_case_types)]
#[repr(C)]
#[derive(
    Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize, Hash,
)]
#[cfg_attr(feature = "conversion", derive(frunk_enum_derive::LabelledGenericEnum))]
pub enum GameEndDtoDifficulty {
    #[serde(rename = "Easy")]
    Easy,
    #[serde(rename = "Medium")]
    Medium,
    #[serde(rename = "Hard")]
    Hard,
    #[serde(rename = "Expert")]
    Expert,
}

impl std::fmt::Display for GameEndDtoDifficulty {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match *self {
            GameEndDtoDifficulty::Easy => write!(f, "Easy"),
            GameEndDtoDifficulty::Medium => write!(f, "Medium"),
            GameEndDtoDifficulty::Hard => write!(f, "Hard"),
            GameEndDtoDifficulty::Expert => write!(f, "Expert"),
        }
    }
}

impl std::str::FromStr for GameEndDtoDifficulty {
    type Err = String;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        match s {
            "Easy" => std::result::Result::Ok(GameEndDtoDifficulty::Easy),
            "Medium" => std::result::Result::Ok(GameEndDtoDifficulty::Medium),
            "Hard" => std::result::Result::Ok(GameEndDtoDifficulty::Hard),
            "Expert" => std::result::Result::Ok(GameEndDtoDifficulty::Expert),
            _ => std::result::Result::Err(format!("Value not valid: {}", s)),
        }
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<GameEndDtoDifficulty>,
    ) -> 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 GameEndDtoDifficulty - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue>
    for header::IntoHeaderValue<GameEndDtoDifficulty>
{
    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 <GameEndDtoDifficulty 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 GameEndDtoDifficulty - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<GameEndDtoDifficulty>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values : std::vec::Vec<GameEndDtoDifficulty> = hdr_values
                .split(',')
                .filter_map(|hdr_value| match hdr_value.trim() {
                    "" => std::option::Option::None,
                    hdr_value => std::option::Option::Some({
                        match <GameEndDtoDifficulty as std::str::FromStr>::from_str(hdr_value) {
                            std::result::Result::Ok(value) => std::result::Result::Ok(value),
                            std::result::Result::Err(err) => std::result::Result::Err(
                                format!("Unable to convert header value '{}' into GameEndDtoDifficulty - {}",
                                    hdr_value, err))
                        }
                    })
                }).collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct HitDetail {
    #[serde(rename = "offset")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<Vec<i32>>,

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

impl HitDetail {
    #[allow(clippy::new_without_default)]
    pub fn new() -> HitDetail {
        HitDetail {
            offset: None,
            miss: None,
        }
    }
}

/// Converts the HitDetail 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 HitDetail {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            self.offset.as_ref().map(|offset| {
                [
                    "offset".to_string(),
                    offset
                        .iter()
                        .map(|x| x.to_string())
                        .collect::<Vec<_>>()
                        .join(","),
                ]
                .join(",")
            }),
            // Skipping non-primitive type miss in query parameter serialization
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 HitDetail".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    "offset" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in HitDetail"
                                .to_string(),
                        )
                    }
                    "miss" => {
                        return std::result::Result::Err(
                            "Parsing a container in this style is not supported in HitDetail"
                                .to_string(),
                        )
                    }
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing HitDetail".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(HitDetail {
            offset: intermediate_rep.offset.into_iter().next(),
            miss: intermediate_rep.miss.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<HitDetail>,
    ) -> 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 HitDetail - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<HitDetail> {
    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 <HitDetail 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 HitDetail - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<HitDetail>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<HitDetail> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <HitDetail as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into HitDetail - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Hitbox {
    #[serde(rename = "point")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub point: Option<models::Point>,

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

impl Hitbox {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Hitbox {
        Hitbox {
            point: None,
            radius: None,
        }
    }
}

/// Converts the Hitbox 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 Hitbox {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            // Skipping non-primitive type point in query parameter serialization
            self.radius
                .as_ref()
                .map(|radius| ["radius".to_string(), radius.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 Hitbox".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "point" => intermediate_rep.point.push(
                        <models::Point as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "radius" => intermediate_rep.radius.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Hitbox".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Hitbox {
            point: intermediate_rep.point.into_iter().next(),
            radius: intermediate_rep.radius.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<Hitbox>,
    ) -> 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 Hitbox - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Hitbox> {
    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 <Hitbox 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 Hitbox - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<Hitbox>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<Hitbox> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <Hitbox as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into Hitbox - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct MapDto {
    #[serde(rename = "point")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub point: Option<models::Hitbox>,

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

impl MapDto {
    #[allow(clippy::new_without_default)]
    pub fn new() -> MapDto {
        MapDto {
            point: None,
            time: None,
        }
    }
}

/// Converts the MapDto 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 MapDto {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            // Skipping non-primitive type point in query parameter serialization
            self.time
                .as_ref()
                .map(|time| ["time".to_string(), time.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 MapDto".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "point" => intermediate_rep.point.push(
                        <models::Hitbox as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "time" => intermediate_rep.time.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing MapDto".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(MapDto {
            point: intermediate_rep.point.into_iter().next(),
            time: intermediate_rep.time.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<MapDto>,
    ) -> 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 MapDto - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<MapDto> {
    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 <MapDto 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 MapDto - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<MapDto>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<MapDto> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <MapDto as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into MapDto - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Point {
    #[serde(rename = "x")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub x: Option<i32>,

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

impl Point {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Point {
        Point { x: None, y: None }
    }
}

/// Converts the Point 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 Point {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            self.x
                .as_ref()
                .map(|x| ["x".to_string(), x.to_string()].join(",")),
            self.y
                .as_ref()
                .map(|y| ["y".to_string(), y.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 Point".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "x" => intermediate_rep.x.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "y" => intermediate_rep.y.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Point".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Point {
            x: intermediate_rep.x.into_iter().next(),
            y: intermediate_rep.y.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<Point>,
    ) -> 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 Point - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Point> {
    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 <Point 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 Point - {}",
                    value, err
                )),
            },
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<Point>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<Point> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <Point as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into Point - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct ResultDto {
    #[serde(rename = "score")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub score: Option<i64>,

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

    #[serde(rename = "Details")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub details: Option<models::HitDetail>,

    #[serde(rename = "averageOffsetTime")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub average_offset_time: Option<i32>,

    #[serde(rename = "Elo")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub elo: Option<models::Tier>,

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

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

impl ResultDto {
    #[allow(clippy::new_without_default)]
    pub fn new() -> ResultDto {
        ResultDto {
            score: None,
            accuracy: None,
            details: None,
            average_offset_time: None,
            elo: None,
            pb: None,
            user: None,
        }
    }
}

/// Converts the ResultDto 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 ResultDto {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            self.score
                .as_ref()
                .map(|score| ["score".to_string(), score.to_string()].join(",")),
            self.accuracy
                .as_ref()
                .map(|accuracy| ["accuracy".to_string(), accuracy.to_string()].join(",")),
            // Skipping non-primitive type Details in query parameter serialization
            self.average_offset_time
                .as_ref()
                .map(|average_offset_time| {
                    [
                        "averageOffsetTime".to_string(),
                        average_offset_time.to_string(),
                    ]
                    .join(",")
                }),
            // Skipping non-primitive type Elo in query parameter serialization
            self.pb
                .as_ref()
                .map(|pb| ["pb".to_string(), pb.to_string()].join(",")),
            self.user
                .as_ref()
                .map(|user| ["user".to_string(), user.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        /// An intermediate representation of the struct to use for parsing.
        #[derive(Default)]
        #[allow(dead_code)]
        struct IntermediateRep {
            pub score: Vec<i64>,
            pub accuracy: Vec<f32>,
            pub details: Vec<models::HitDetail>,
            pub average_offset_time: Vec<i32>,
            pub elo: Vec<models::Tier>,
            pub pb: Vec<bool>,
            pub user: Vec<String>,
        }

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 ResultDto".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "score" => intermediate_rep.score.push(
                        <i64 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "accuracy" => intermediate_rep.accuracy.push(
                        <f32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "Details" => intermediate_rep.details.push(
                        <models::HitDetail as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "averageOffsetTime" => intermediate_rep.average_offset_time.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "Elo" => intermediate_rep.elo.push(
                        <models::Tier as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "pb" => intermediate_rep.pb.push(
                        <bool as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "user" => intermediate_rep.user.push(
                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing ResultDto".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(ResultDto {
            score: intermediate_rep.score.into_iter().next(),
            accuracy: intermediate_rep.accuracy.into_iter().next(),
            details: intermediate_rep.details.into_iter().next(),
            average_offset_time: intermediate_rep.average_offset_time.into_iter().next(),
            elo: intermediate_rep.elo.into_iter().next(),
            pb: intermediate_rep.pb.into_iter().next(),
            user: intermediate_rep.user.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<ResultDto>,
    ) -> 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 ResultDto - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<ResultDto> {
    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 <ResultDto 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 ResultDto - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<ResultDto>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<ResultDto> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <ResultDto as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into ResultDto - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Spawn {
    #[serde(rename = "hitbox")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hitbox: Option<models::Hitbox>,

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

impl Spawn {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Spawn {
        Spawn {
            hitbox: None,
            time: None,
        }
    }
}

/// Converts the Spawn 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 Spawn {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            // Skipping non-primitive type hitbox in query parameter serialization
            self.time
                .as_ref()
                .map(|time| ["time".to_string(), time.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 Spawn".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "hitbox" => intermediate_rep.hitbox.push(
                        <models::Hitbox as std::str::FromStr>::from_str(val)
                            .map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "time" => intermediate_rep.time.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Spawn".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Spawn {
            hitbox: intermediate_rep.hitbox.into_iter().next(),
            time: intermediate_rep.time.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<Spawn>,
    ) -> 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 Spawn - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Spawn> {
    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 <Spawn 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 Spawn - {}",
                    value, err
                )),
            },
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<Spawn>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<Spawn> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <Spawn as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into Spawn - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct Tier {
    #[serde(rename = "rank")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rank: Option<i32>,

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

impl Tier {
    #[allow(clippy::new_without_default)]
    pub fn new() -> Tier {
        Tier {
            rank: None,
            percent: None,
        }
    }
}

/// Converts the Tier 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 Tier {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            self.rank
                .as_ref()
                .map(|rank| ["rank".to_string(), rank.to_string()].join(",")),
            self.percent
                .as_ref()
                .map(|percent| ["percent".to_string(), percent.to_string()].join(",")),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 Tier".to_string())
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "rank" => intermediate_rep.rank.push(
                        <i32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "percent" => intermediate_rep.percent.push(
                        <f32 as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing Tier".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(Tier {
            rank: intermediate_rep.rank.into_iter().next(),
            percent: intermediate_rep.percent.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<Tier>,
    ) -> 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 Tier - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<Tier> {
    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 <Tier 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 Tier - {}",
                    value, err
                )),
            },
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<Tier>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<Tier> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <Tier as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into Tier - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, validator::Validate)]
#[cfg_attr(feature = "conversion", derive(frunk::LabelledGeneric))]
pub struct UserDto {
    #[serde(rename = "userName")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub user_name: Option<String>,

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

impl UserDto {
    #[allow(clippy::new_without_default)]
    pub fn new() -> UserDto {
        UserDto {
            user_name: None,
            profile_picture: None,
        }
    }
}

/// Converts the UserDto 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 UserDto {
    fn to_string(&self) -> String {
        let params: Vec<Option<String>> = vec![
            self.user_name
                .as_ref()
                .map(|user_name| ["userName".to_string(), user_name.to_string()].join(",")),
            self.profile_picture.as_ref().map(|profile_picture| {
                ["profilePicture".to_string(), profile_picture.to_string()].join(",")
            }),
        ];

        params.into_iter().flatten().collect::<Vec<_>>().join(",")
    }
}

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

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

        let mut intermediate_rep = IntermediateRep::default();

        // Parse into intermediate representation
        let mut string_iter = s.split(',');
        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 UserDto".to_string(),
                    )
                }
            };

            if let Some(key) = key_result {
                #[allow(clippy::match_single_binding)]
                match key {
                    #[allow(clippy::redundant_clone)]
                    "userName" => intermediate_rep.user_name.push(
                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    #[allow(clippy::redundant_clone)]
                    "profilePicture" => intermediate_rep.profile_picture.push(
                        <String as std::str::FromStr>::from_str(val).map_err(|x| x.to_string())?,
                    ),
                    _ => {
                        return std::result::Result::Err(
                            "Unexpected key while parsing UserDto".to_string(),
                        )
                    }
                }
            }

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

        // Use the intermediate representation to return the struct
        std::result::Result::Ok(UserDto {
            user_name: intermediate_rep.user_name.into_iter().next(),
            profile_picture: intermediate_rep.profile_picture.into_iter().next(),
        })
    }
}

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

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

    fn try_from(
        hdr_value: header::IntoHeaderValue<UserDto>,
    ) -> 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 UserDto - value: {} is invalid {}",
                hdr_value, e
            )),
        }
    }
}

#[cfg(any(feature = "client", feature = "server"))]
impl std::convert::TryFrom<hyper::header::HeaderValue> for header::IntoHeaderValue<UserDto> {
    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 <UserDto 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 UserDto - {}",
                        value, err
                    )),
                }
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert header: {:?} to string: {}",
                hdr_value, e
            )),
        }
    }
}

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

    fn try_from(
        hdr_values: header::IntoHeaderValue<Vec<UserDto>>,
    ) -> std::result::Result<Self, Self::Error> {
        let hdr_values: Vec<String> = hdr_values
            .0
            .into_iter()
            .map(|hdr_value| hdr_value.to_string())
            .collect();

        match hyper::header::HeaderValue::from_str(&hdr_values.join(", ")) {
            std::result::Result::Ok(hdr_value) => std::result::Result::Ok(hdr_value),
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to convert {:?} into a header - {}",
                hdr_values, e
            )),
        }
    }
}

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

    fn try_from(hdr_values: hyper::header::HeaderValue) -> std::result::Result<Self, Self::Error> {
        match hdr_values.to_str() {
            std::result::Result::Ok(hdr_values) => {
                let hdr_values: std::vec::Vec<UserDto> = hdr_values
                    .split(',')
                    .filter_map(|hdr_value| match hdr_value.trim() {
                        "" => std::option::Option::None,
                        hdr_value => std::option::Option::Some({
                            match <UserDto as std::str::FromStr>::from_str(hdr_value) {
                                std::result::Result::Ok(value) => std::result::Result::Ok(value),
                                std::result::Result::Err(err) => std::result::Result::Err(format!(
                                    "Unable to convert header value '{}' into UserDto - {}",
                                    hdr_value, err
                                )),
                            }
                        }),
                    })
                    .collect::<std::result::Result<std::vec::Vec<_>, String>>()?;

                std::result::Result::Ok(header::IntoHeaderValue(hdr_values))
            }
            std::result::Result::Err(e) => std::result::Result::Err(format!(
                "Unable to parse header: {:?} as a string - {}",
                hdr_values, e
            )),
        }
    }
}