mod types {
    #[doc = r" Error types."]
    pub mod error {
        #[doc = r" Error from a TryFrom or FromStr implementation."]
        pub struct ConversionError(::std::borrow::Cow<'static, str>);
        impl ::std::error::Error for ConversionError {}
        impl ::std::fmt::Display for ConversionError {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Display::fmt(&self.0, f)
            }
        }
        impl ::std::fmt::Debug for ConversionError {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Debug::fmt(&self.0, f)
            }
        }
        impl From<&'static str> for ConversionError {
            fn from(value: &'static str) -> Self {
                Self(value.into())
            }
        }
        impl From<String> for ConversionError {
            fn from(value: String) -> Self {
                Self(value.into())
            }
        }
    }
    #[doc = "AllTheTraits"]
    #[doc = r""]
    #[doc = r" <details><summary>JSON schema</summary>"]
    #[doc = r""]
    #[doc = r" ```json"]
    #[doc = "{"]
    #[doc = "  \"title\": \"AllTheTraits\","]
    #[doc = "  \"type\": \"object\","]
    #[doc = "  \"required\": ["]
    #[doc = "    \"ok\""]
    #[doc = "  ],"]
    #[doc = "  \"properties\": {"]
    #[doc = "    \"ok\": {"]
    #[doc = "      \"type\": \"string\""]
    #[doc = "    }"]
    #[doc = "  }"]
    #[doc = "}"]
    #[doc = r" ```"]
    #[doc = r" </details>"]
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Debug,
        Eq,
        Hash,
        JsonSchema,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub struct AllTheTraits {
        pub ok: String,
    }
    impl From<&AllTheTraits> for AllTheTraits {
        fn from(value: &AllTheTraits) -> Self {
            value.clone()
        }
    }
    impl AllTheTraits {
        pub fn builder() -> builder::AllTheTraits {
            Default::default()
        }
    }
    #[doc = "CompoundType"]
    #[doc = r""]
    #[doc = r" <details><summary>JSON schema</summary>"]
    #[doc = r""]
    #[doc = r" ```json"]
    #[doc = "{"]
    #[doc = "  \"title\": \"CompoundType\","]
    #[doc = "  \"type\": \"object\","]
    #[doc = "  \"required\": ["]
    #[doc = "    \"value1\","]
    #[doc = "    \"value2\""]
    #[doc = "  ],"]
    #[doc = "  \"properties\": {"]
    #[doc = "    \"value1\": {"]
    #[doc = "      \"type\": \"string\""]
    #[doc = "    },"]
    #[doc = "    \"value2\": {"]
    #[doc = "      \"type\": \"integer\","]
    #[doc = "      \"format\": \"uint64\","]
    #[doc = "      \"minimum\": 0.0"]
    #[doc = "    }"]
    #[doc = "  }"]
    #[doc = "}"]
    #[doc = r" ```"]
    #[doc = r" </details>"]
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug, JsonSchema)]
    pub struct CompoundType {
        pub value1: String,
        pub value2: u64,
    }
    impl From<&CompoundType> for CompoundType {
        fn from(value: &CompoundType) -> Self {
            value.clone()
        }
    }
    impl CompoundType {
        pub fn builder() -> builder::CompoundType {
            Default::default()
        }
    }
    #[doc = "Pair"]
    #[doc = r""]
    #[doc = r" <details><summary>JSON schema</summary>"]
    #[doc = r""]
    #[doc = r" ```json"]
    #[doc = "{"]
    #[doc = "  \"title\": \"Pair\","]
    #[doc = "  \"type\": \"object\","]
    #[doc = "  \"properties\": {"]
    #[doc = "    \"a\": {"]
    #[doc = "      \"default\": \"One\","]
    #[doc = "      \"$ref\": \"#/definitions/StringEnum\""]
    #[doc = "    },"]
    #[doc = "    \"b\": {"]
    #[doc = "      \"default\": \"Two\","]
    #[doc = "      \"$ref\": \"#/definitions/StringEnum\""]
    #[doc = "    }"]
    #[doc = "  }"]
    #[doc = "}"]
    #[doc = r" ```"]
    #[doc = r" </details>"]
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug, JsonSchema)]
    pub struct Pair {
        #[serde(default = "defaults::pair_a")]
        pub a: StringEnum,
        #[serde(default = "defaults::pair_b")]
        pub b: StringEnum,
    }
    impl From<&Pair> for Pair {
        fn from(value: &Pair) -> Self {
            value.clone()
        }
    }
    impl Pair {
        pub fn builder() -> builder::Pair {
            Default::default()
        }
    }
    #[doc = "StringEnum"]
    #[doc = r""]
    #[doc = r" <details><summary>JSON schema</summary>"]
    #[doc = r""]
    #[doc = r" ```json"]
    #[doc = "{"]
    #[doc = "  \"type\": \"string\","]
    #[doc = "  \"enum\": ["]
    #[doc = "    \"One\","]
    #[doc = "    \"Two\","]
    #[doc = "    \"BuckleMyShoe\""]
    #[doc = "  ]"]
    #[doc = "}"]
    #[doc = r" ```"]
    #[doc = r" </details>"]
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        JsonSchema,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum StringEnum {
        One,
        Two,
        BuckleMyShoe,
    }
    impl From<&StringEnum> for StringEnum {
        fn from(value: &StringEnum) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for StringEnum {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::One => write!(f, "One"),
                Self::Two => write!(f, "Two"),
                Self::BuckleMyShoe => write!(f, "BuckleMyShoe"),
            }
        }
    }
    impl std::str::FromStr for StringEnum {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> Result<Self, self::error::ConversionError> {
            match value {
                "One" => Ok(Self::One),
                "Two" => Ok(Self::Two),
                "BuckleMyShoe" => Ok(Self::BuckleMyShoe),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl std::convert::TryFrom<&str> for StringEnum {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl std::convert::TryFrom<&String> for StringEnum {
        type Error = self::error::ConversionError;
        fn try_from(value: &String) -> Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl std::convert::TryFrom<String> for StringEnum {
        type Error = self::error::ConversionError;
        fn try_from(value: String) -> Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    #[doc = r" Types for composing complex structures."]
    pub mod builder {
        #[derive(Clone, Debug)]
        pub struct AllTheTraits {
            ok: Result<String, String>,
        }
        impl Default for AllTheTraits {
            fn default() -> Self {
                Self {
                    ok: Err("no value supplied for ok".to_string()),
                }
            }
        }
        impl AllTheTraits {
            pub fn ok<T>(mut self, value: T) -> Self
            where
                T: std::convert::TryInto<String>,
                T::Error: std::fmt::Display,
            {
                self.ok = value
                    .try_into()
                    .map_err(|e| format!("error converting supplied value for ok: {}", e));
                self
            }
        }
        impl std::convert::TryFrom<AllTheTraits> for super::AllTheTraits {
            type Error = super::error::ConversionError;
            fn try_from(value: AllTheTraits) -> Result<Self, super::error::ConversionError> {
                Ok(Self { ok: value.ok? })
            }
        }
        impl From<super::AllTheTraits> for AllTheTraits {
            fn from(value: super::AllTheTraits) -> Self {
                Self { ok: Ok(value.ok) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CompoundType {
            value1: Result<String, String>,
            value2: Result<u64, String>,
        }
        impl Default for CompoundType {
            fn default() -> Self {
                Self {
                    value1: Err("no value supplied for value1".to_string()),
                    value2: Err("no value supplied for value2".to_string()),
                }
            }
        }
        impl CompoundType {
            pub fn value1<T>(mut self, value: T) -> Self
            where
                T: std::convert::TryInto<String>,
                T::Error: std::fmt::Display,
            {
                self.value1 = value
                    .try_into()
                    .map_err(|e| format!("error converting supplied value for value1: {}", e));
                self
            }
            pub fn value2<T>(mut self, value: T) -> Self
            where
                T: std::convert::TryInto<u64>,
                T::Error: std::fmt::Display,
            {
                self.value2 = value
                    .try_into()
                    .map_err(|e| format!("error converting supplied value for value2: {}", e));
                self
            }
        }
        impl std::convert::TryFrom<CompoundType> for super::CompoundType {
            type Error = super::error::ConversionError;
            fn try_from(value: CompoundType) -> Result<Self, super::error::ConversionError> {
                Ok(Self {
                    value1: value.value1?,
                    value2: value.value2?,
                })
            }
        }
        impl From<super::CompoundType> for CompoundType {
            fn from(value: super::CompoundType) -> Self {
                Self {
                    value1: Ok(value.value1),
                    value2: Ok(value.value2),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct Pair {
            a: Result<super::StringEnum, String>,
            b: Result<super::StringEnum, String>,
        }
        impl Default for Pair {
            fn default() -> Self {
                Self {
                    a: Ok(super::defaults::pair_a()),
                    b: Ok(super::defaults::pair_b()),
                }
            }
        }
        impl Pair {
            pub fn a<T>(mut self, value: T) -> Self
            where
                T: std::convert::TryInto<super::StringEnum>,
                T::Error: std::fmt::Display,
            {
                self.a = value
                    .try_into()
                    .map_err(|e| format!("error converting supplied value for a: {}", e));
                self
            }
            pub fn b<T>(mut self, value: T) -> Self
            where
                T: std::convert::TryInto<super::StringEnum>,
                T::Error: std::fmt::Display,
            {
                self.b = value
                    .try_into()
                    .map_err(|e| format!("error converting supplied value for b: {}", e));
                self
            }
        }
        impl std::convert::TryFrom<Pair> for super::Pair {
            type Error = super::error::ConversionError;
            fn try_from(value: Pair) -> Result<Self, super::error::ConversionError> {
                Ok(Self {
                    a: value.a?,
                    b: value.b?,
                })
            }
        }
        impl From<super::Pair> for Pair {
            fn from(value: super::Pair) -> Self {
                Self {
                    a: Ok(value.a),
                    b: Ok(value.b),
                }
            }
        }
    }
    #[doc = r" Generation of default values for serde."]
    pub mod defaults {
        pub(super) fn pair_a() -> super::StringEnum {
            super::StringEnum::One
        }
        pub(super) fn pair_b() -> super::StringEnum {
            super::StringEnum::Two
        }
    }
}
pub fn do_stuff(
    body: &types::CompoundType,
    string: &str,
    opt_int: Option<u32>,
    strenum: types::StringEnum,
) -> types::CompoundType {
    todo!()
}