Server Test Python

/// :param path str:

/// :param message str:

/// Describes one specific validation failure for an input member.

pub struct ValidationExceptionField {

    #[pyo3(get, set)]

    /// :type str:

    /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.

    pub path: ::std::string::String,

    #[pyo3(get, set)]

    /// :type str:

    /// A detailed description of the validation failure.

    pub message: ::std::string::String,

}

impl ValidationExceptionField {

    /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.

    pub fn path(&self) -> &str {

        use std::ops::Deref;

        self.path.deref()

    }

    /// A detailed description of the validation failure.

    pub fn message(&self) -> &str {

        use std::ops::Deref;

        self.message.deref()

    }

}

impl ValidationExceptionField {

    pub fn new(path: ::std::string::String, message: ::std::string::String) -> Self {

        Self { path, message }

impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ValidationExceptionField> {

        ob.extract::<ValidationExceptionField>().map(Box::new)

impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ValidationExceptionField> {

impl ValidationExceptionField {

    /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).

    pub fn builder() -> crate::model::validation_exception_field::Builder {

        crate::model::validation_exception_field::Builder::default()

/// A union with a representative set of types for members.

#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]

pub enum MyUnion {

    BlobValue(::aws_smithy_http_server_python::types::Blob),

    BooleanValue(bool),

    EnumValue(crate::model::FooEnum),

    ListValue(::std::vec::Vec<::std::string::String>),

    MapValue(::std::collections::HashMap<::std::string::String, ::std::string::String>),

    NumberValue(i32),

    StringValue(::std::string::String),

    StructureValue(crate::model::GreetingStruct),

    TimestampValue(::aws_smithy_http_server_python::types::DateTime),

impl MyUnion {

    /// Tries to convert the enum instance into [`BlobValue`](crate::model::MyUnion::BlobValue), extracting the inner [`Blob`](::aws_smithy_http_server_python::types::Blob).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_blob_value(

        &self,

    ) -> ::std::result::Result<&::aws_smithy_http_server_python::types::Blob, &Self> {

        if let MyUnion::BlobValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    /// Returns true if this is a [`BlobValue`](crate::model::MyUnion::BlobValue).

    pub fn is_blob_value(&self) -> bool {

        self.as_blob_value().is_ok()

    /// Tries to convert the enum instance into [`BooleanValue`](crate::model::MyUnion::BooleanValue), extracting the inner [`bool`](bool).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_boolean_value(&self) -> ::std::result::Result<&bool, &Self> {

        if let MyUnion::BooleanValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

    /// Returns true if this is a [`BooleanValue`](crate::model::MyUnion::BooleanValue).

    pub fn is_boolean_value(&self) -> bool {

        self.as_boolean_value().is_ok()

    /// Tries to convert the enum instance into [`EnumValue`](crate::model::MyUnion::EnumValue), extracting the inner [`FooEnum`](crate::model::FooEnum).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_enum_value(&self) -> ::std::result::Result<&crate::model::FooEnum, &Self> {

        if let MyUnion::EnumValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`EnumValue`](crate::model::MyUnion::EnumValue).

    pub fn is_enum_value(&self) -> bool {

        self.as_enum_value().is_ok()

    }

    /// Tries to convert the enum instance into [`ListValue`](crate::model::MyUnion::ListValue), extracting the inner [`Vec`](::std::vec::Vec).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_list_value(

        &self,

    ) -> ::std::result::Result<&::std::vec::Vec<::std::string::String>, &Self> {

        if let MyUnion::ListValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`ListValue`](crate::model::MyUnion::ListValue).

    pub fn is_list_value(&self) -> bool {

        self.as_list_value().is_ok()

    }

    /// Tries to convert the enum instance into [`MapValue`](crate::model::MyUnion::MapValue), extracting the inner [`HashMap`](::std::collections::HashMap).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_map_value(

        &self,

    ) -> ::std::result::Result<

        &::std::collections::HashMap<::std::string::String, ::std::string::String>,

        &Self,

    > {

        if let MyUnion::MapValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`MapValue`](crate::model::MyUnion::MapValue).

    pub fn is_map_value(&self) -> bool {

        self.as_map_value().is_ok()

    }

    /// Tries to convert the enum instance into [`NumberValue`](crate::model::MyUnion::NumberValue), extracting the inner [`i32`](i32).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_number_value(&self) -> ::std::result::Result<&i32, &Self> {

        if let MyUnion::NumberValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`NumberValue`](crate::model::MyUnion::NumberValue).

    pub fn is_number_value(&self) -> bool {

        self.as_number_value().is_ok()

    }

    /// Tries to convert the enum instance into [`StringValue`](crate::model::MyUnion::StringValue), extracting the inner [`String`](::std::string::String).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_string_value(&self) -> ::std::result::Result<&::std::string::String, &Self> {

        if let MyUnion::StringValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`StringValue`](crate::model::MyUnion::StringValue).

    pub fn is_string_value(&self) -> bool {

        self.as_string_value().is_ok()

    }

    /// Tries to convert the enum instance into [`StructureValue`](crate::model::MyUnion::StructureValue), extracting the inner [`GreetingStruct`](crate::model::GreetingStruct).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_structure_value(

        &self,

    ) -> ::std::result::Result<&crate::model::GreetingStruct, &Self> {

        if let MyUnion::StructureValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`StructureValue`](crate::model::MyUnion::StructureValue).

    pub fn is_structure_value(&self) -> bool {

        self.as_structure_value().is_ok()

    }

    /// Tries to convert the enum instance into [`TimestampValue`](crate::model::MyUnion::TimestampValue), extracting the inner [`DateTime`](::aws_smithy_http_server_python::types::DateTime).

    /// Returns `Err(&Self)` if it can't be converted.

    pub fn as_timestamp_value(

        &self,

    ) -> ::std::result::Result<&::aws_smithy_http_server_python::types::DateTime, &Self> {

        if let MyUnion::TimestampValue(val) = &self {

            ::std::result::Result::Ok(val)

        } else {

            ::std::result::Result::Err(self)

        }

    }

    /// Returns true if this is a [`TimestampValue`](crate::model::MyUnion::TimestampValue).

    pub fn is_timestamp_value(&self) -> bool {

        self.as_timestamp_value().is_ok()

    }

}

#[pyo3::pyclass(name = "MyUnion")]

#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]

pub struct PyUnionMarkerMyUnion(pub MyUnion);

#[::pyo3::pymethods]

impl PyUnionMarkerMyUnion {

    #[staticmethod]

    /// Creates a new union instance of [`BlobValue`](crate::model::MyUnion::BlobValue)

    /// :param data json_rpc11.types.Blob:

    /// :rtype MyUnion:

    pub fn blob_value(data: ::aws_smithy_http_server_python::types::Blob) -> Self {

        Self(MyUnion::BlobValue(data))

    }

    /// Tries to convert the enum instance into [`BlobValue`](crate::model::MyUnion::BlobValue), extracting the inner [`Blob`](::aws_smithy_http_server_python::types::Blob).

    /// :rtype json_rpc11.types.Blob:

    pub fn as_blob_value(&self) -> ::pyo3::PyResult<::aws_smithy_http_server_python::types::Blob> {

        match self.0.as_blob_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type json_rpc11.types.Blob",

            )),

        }

    }

    /// Returns true if this is a [`BlobValue`](crate::model::MyUnion::BlobValue).

    /// :rtype bool:

    pub fn is_blob_value(&self) -> bool {

        self.0.is_blob_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`BooleanValue`](crate::model::MyUnion::BooleanValue)

    /// :param data bool:

    /// :rtype MyUnion:

    pub fn boolean_value(data: bool) -> Self {

        Self(MyUnion::BooleanValue(data))

    }

    /// Tries to convert the enum instance into [`BooleanValue`](crate::model::MyUnion::BooleanValue), extracting the inner [`bool`](bool).

    /// :rtype bool:

    pub fn as_boolean_value(&self) -> ::pyo3::PyResult<bool> {

        match self.0.as_boolean_value() {

            Ok(variant) => Ok(*variant),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type bool",

            )),

        }

    }

    /// Returns true if this is a [`BooleanValue`](crate::model::MyUnion::BooleanValue).

    /// :rtype bool:

    pub fn is_boolean_value(&self) -> bool {

        self.0.is_boolean_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`EnumValue`](crate::model::MyUnion::EnumValue)

    /// :param data json_rpc11.model.FooEnum:

    /// :rtype MyUnion:

    pub fn enum_value(data: crate::model::FooEnum) -> Self {

        Self(MyUnion::EnumValue(data))

    }

    /// Tries to convert the enum instance into [`EnumValue`](crate::model::MyUnion::EnumValue), extracting the inner [`FooEnum`](crate::model::FooEnum).

    /// :rtype json_rpc11.model.FooEnum:

    pub fn as_enum_value(&self) -> ::pyo3::PyResult<crate::model::FooEnum> {

        match self.0.as_enum_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type json_rpc11.model.FooEnum",

            )),

        }

    }

    /// Returns true if this is a [`EnumValue`](crate::model::MyUnion::EnumValue).

    /// :rtype bool:

    pub fn is_enum_value(&self) -> bool {

        self.0.is_enum_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`ListValue`](crate::model::MyUnion::ListValue)

    /// :param data typing.List\[str\]:

    /// :rtype MyUnion:

    pub fn list_value(data: ::std::vec::Vec<::std::string::String>) -> Self {

        Self(MyUnion::ListValue(data))

    }

    /// Tries to convert the enum instance into [`ListValue`](crate::model::MyUnion::ListValue), extracting the inner [`Vec`](::std::vec::Vec).

    /// :rtype typing.List\[str\]:

    pub fn as_list_value(&self) -> ::pyo3::PyResult<::std::vec::Vec<::std::string::String>> {

        match self.0.as_list_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type typing.List\[str\]",

            )),

        }

    }

    /// Returns true if this is a [`ListValue`](crate::model::MyUnion::ListValue).

    /// :rtype bool:

    pub fn is_list_value(&self) -> bool {

        self.0.is_list_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`MapValue`](crate::model::MyUnion::MapValue)

    /// :param data typing.Dict\[str, str\]:

    /// :rtype MyUnion:

    pub fn map_value(

        data: ::std::collections::HashMap<::std::string::String, ::std::string::String>,

    ) -> Self {

        Self(MyUnion::MapValue(data))

    }

    /// Tries to convert the enum instance into [`MapValue`](crate::model::MyUnion::MapValue), extracting the inner [`HashMap`](::std::collections::HashMap).

    /// :rtype typing.Dict\[str, str\]:

    pub fn as_map_value(

        &self,

    ) -> ::pyo3::PyResult<::std::collections::HashMap<::std::string::String, ::std::string::String>>

    {

        match self.0.as_map_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type typing.Dict\[str, str\]",

            )),

        }

    }

    /// Returns true if this is a [`MapValue`](crate::model::MyUnion::MapValue).

    /// :rtype bool:

    pub fn is_map_value(&self) -> bool {

        self.0.is_map_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`NumberValue`](crate::model::MyUnion::NumberValue)

    /// :param data int:

    /// :rtype MyUnion:

    pub fn number_value(data: i32) -> Self {

        Self(MyUnion::NumberValue(data))

    }

    /// Tries to convert the enum instance into [`NumberValue`](crate::model::MyUnion::NumberValue), extracting the inner [`i32`](i32).

    /// :rtype int:

    pub fn as_number_value(&self) -> ::pyo3::PyResult<i32> {

        match self.0.as_number_value() {

            Ok(variant) => Ok(*variant),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type int",

            )),

        }

    }

    /// Returns true if this is a [`NumberValue`](crate::model::MyUnion::NumberValue).

    /// :rtype bool:

    pub fn is_number_value(&self) -> bool {

        self.0.is_number_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`StringValue`](crate::model::MyUnion::StringValue)

    /// :param data str:

    /// :rtype MyUnion:

    pub fn string_value(data: ::std::string::String) -> Self {

        Self(MyUnion::StringValue(data))

    }

    /// Tries to convert the enum instance into [`StringValue`](crate::model::MyUnion::StringValue), extracting the inner [`String`](::std::string::String).

    /// :rtype str:

    pub fn as_string_value(&self) -> ::pyo3::PyResult<::std::string::String> {

        match self.0.as_string_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type str",

            )),

        }

    }

    /// Returns true if this is a [`StringValue`](crate::model::MyUnion::StringValue).

    /// :rtype bool:

    pub fn is_string_value(&self) -> bool {

        self.0.is_string_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`StructureValue`](crate::model::MyUnion::StructureValue)

    /// :param data json_rpc11.model.GreetingStruct:

    /// :rtype MyUnion:

    pub fn structure_value(data: crate::model::GreetingStruct) -> Self {

        Self(MyUnion::StructureValue(data))

    }

    /// Tries to convert the enum instance into [`StructureValue`](crate::model::MyUnion::StructureValue), extracting the inner [`GreetingStruct`](crate::model::GreetingStruct).

    /// :rtype json_rpc11.model.GreetingStruct:

    pub fn as_structure_value(&self) -> ::pyo3::PyResult<crate::model::GreetingStruct> {

        match self.0.as_structure_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type json_rpc11.model.GreetingStruct",

            )),

        }

    }

    /// Returns true if this is a [`StructureValue`](crate::model::MyUnion::StructureValue).

    /// :rtype bool:

    pub fn is_structure_value(&self) -> bool {

        self.0.is_structure_value()

    }

    #[staticmethod]

    /// Creates a new union instance of [`TimestampValue`](crate::model::MyUnion::TimestampValue)

    /// :param data json_rpc11.types.DateTime:

    /// :rtype MyUnion:

    pub fn timestamp_value(data: ::aws_smithy_http_server_python::types::DateTime) -> Self {

        Self(MyUnion::TimestampValue(data))

    }

    /// Tries to convert the enum instance into [`TimestampValue`](crate::model::MyUnion::TimestampValue), extracting the inner [`DateTime`](::aws_smithy_http_server_python::types::DateTime).

    /// :rtype json_rpc11.types.DateTime:

    pub fn as_timestamp_value(

        &self,

    ) -> ::pyo3::PyResult<::aws_smithy_http_server_python::types::DateTime> {

        match self.0.as_timestamp_value() {

            Ok(variant) => Ok(variant.clone()),

            Err(_) => Err(::pyo3::exceptions::PyValueError::new_err(

                r"MyUnion variant is not of type json_rpc11.types.DateTime",

            )),

        }

    }

    /// Returns true if this is a [`TimestampValue`](crate::model::MyUnion::TimestampValue).

    /// :rtype bool:

    pub fn is_timestamp_value(&self) -> bool {

        self.0.is_timestamp_value()

    }

}

impl ::pyo3::IntoPy<::pyo3::PyObject> for MyUnion {

    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {

        PyUnionMarkerMyUnion(self).into_py(py)

    }

}

impl<'source> ::pyo3::FromPyObject<'source> for MyUnion {

    fn extract(obj: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {

        let data: PyUnionMarkerMyUnion = obj.extract()?;

        Ok(data.0)

    }

}

#[::pyo3::pyclass]

/// :param hi typing.Optional\[str\]:

/// :rtype None:

#[allow(missing_docs)] // documentation missing in model

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub struct GreetingStruct {

    #[pyo3(get, set)]

    /// :type typing.Optional\[str\]:

    #[allow(missing_docs)] // documentation missing in model

    pub hi: ::std::option::Option<::std::string::String>,

}

impl GreetingStruct {

    #[allow(missing_docs)] // documentation missing in model

    pub fn hi(&self) -> ::std::option::Option<&str> {

        self.hi.as_deref()

    }

}

#[allow(clippy::new_without_default)]

#[allow(clippy::too_many_arguments)]

#[::pyo3::pymethods]

impl GreetingStruct {

    #[new]

    pub fn new(hi: ::std::option::Option<::std::string::String>) -> Self {

        Self { hi }

    }

    fn __repr__(&self) -> String {

        format!("{self:?}")

    }

    fn __str__(&self) -> String {

        format!("{self:?}")

    }

}

impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<GreetingStruct> {

    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {

        ob.extract::<GreetingStruct>().map(Box::new)

    }

}

impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<GreetingStruct> {

    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {

        (*self).into_py(py)

    }

}

impl crate::constrained::Constrained for crate::model::GreetingStruct {

    type Unconstrained = crate::model::greeting_struct_internal::Builder;

}

impl GreetingStruct {

    /// Creates a new builder-style object to manufacture [`GreetingStruct`](crate::model::GreetingStruct).

    pub fn builder() -> crate::model::greeting_struct::Builder {

        crate::model::greeting_struct::Builder::default()

    }

}

#[::pyo3::pyclass]

#[allow(missing_docs)] // documentation missing in model

#[derive(

    ::std::clone::Clone,

    ::std::cmp::Eq,

    ::std::cmp::Ord,

    ::std::cmp::PartialEq,

    ::std::cmp::PartialOrd,

    ::std::fmt::Debug,

    ::std::hash::Hash,

)]

pub enum FooEnum {

    #[allow(missing_docs)] // documentation missing in model

    Zero,

    #[allow(missing_docs)] // documentation missing in model

    One,

    #[allow(missing_docs)] // documentation missing in model

    Bar,

    #[allow(missing_docs)] // documentation missing in model

    Baz,

    #[allow(missing_docs)] // documentation missing in model

    Foo,

}

pub(crate) mod foo_enum_internal {

    #[derive(Debug, PartialEq)]

    pub struct ConstraintViolation(pub(crate) ::std::string::String);

    impl ::std::fmt::Display for ConstraintViolation {

        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

            write!(

                f,

                r#"Value provided for 'aws.protocoltests.shared#FooEnum' failed to satisfy constraint: Member must satisfy enum value set: [Foo, Baz, Bar, 1, 0]"#

            )

        }

    }

    impl ::std::error::Error for ConstraintViolation {}

    impl ConstraintViolation {

        pub(crate) fn as_validation_exception_field(

            self,

            path: ::std::string::String,

        ) -> crate::model::ValidationExceptionField {

            crate::model::ValidationExceptionField {

                message: format!(

                    r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [Foo, Baz, Bar, 1, 0]"#,

                    &path

                ),

                path,

            }

        }

    }

}

impl ::std::convert::TryFrom<&str> for FooEnum {

    type Error = crate::model::foo_enum_internal::ConstraintViolation;

    fn try_from(

        s: &str,

    ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {

        match s {

            "0" => Ok(FooEnum::Zero),

            "1" => Ok(FooEnum::One),

            "Bar" => Ok(FooEnum::Bar),

            "Baz" => Ok(FooEnum::Baz),

            "Foo" => Ok(FooEnum::Foo),

            _ => Err(crate::model::foo_enum_internal::ConstraintViolation(

                s.to_owned(),

            )),

        }

    }

}

impl ::std::convert::TryFrom<::std::string::String> for FooEnum {

    type Error = crate::model::foo_enum_internal::ConstraintViolation;

    fn try_from(

        s: ::std::string::String,

    ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>

    {

        s.as_str().try_into()

    }

}

impl std::str::FromStr for FooEnum {

    type Err = crate::model::foo_enum_internal::ConstraintViolation;

    fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {

        Self::try_from(s)

    }

}

impl FooEnum {

    /// Returns the `&str` value of the enum member.

    pub fn as_str(&self) -> &str {

        match self {

            FooEnum::Zero => "0",

            FooEnum::One => "1",

            FooEnum::Bar => "Bar",

            FooEnum::Baz => "Baz",

            FooEnum::Foo => "Foo",

        }

    }

    /// Returns all the `&str` representations of the enum members.

    pub const fn values() -> &'static [&'static str] {

        &["0", "1", "Bar", "Baz", "Foo"]

    }

}

impl ::std::convert::AsRef<str> for FooEnum {

    fn as_ref(&self) -> &str {

        self.as_str()

    }

}

#[::pyo3::pymethods]

impl FooEnum {

    #[getter]

    pub fn name(&self) -> &str {

        match self {

            FooEnum::Zero => "Zero",

            FooEnum::One => "One",

            FooEnum::Bar => "Bar",

            FooEnum::Baz => "Baz",

            FooEnum::Foo => "Foo",

        }

    }

    #[getter]

    pub fn value(&self) -> &str {

        self.as_str()

    }

    fn __repr__(&self) -> String {

        self.as_str().to_owned()

    }

    fn __str__(&self) -> String {

        self.as_str().to_owned()

    }

}

impl crate::constrained::Constrained for FooEnum {

    type Unconstrained = ::std::string::String;

}

impl ::std::convert::From<::std::string::String>

    for crate::constrained::MaybeConstrained<crate::model::FooEnum>

{

    fn from(value: ::std::string::String) -> Self {

        Self::Unconstrained(value)

    }

}

#[::pyo3::pyclass]

/// :param foo typing.Optional\[str\]:

/// :rtype None:

#[allow(missing_docs)] // documentation missing in model

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub struct ComplexNestedErrorData {

    #[pyo3(get, set)]

    /// :type typing.Optional\[str\]:

    #[allow(missing_docs)] // documentation missing in model

    pub foo: ::std::option::Option<::std::string::String>,

}

impl ComplexNestedErrorData {

    #[allow(missing_docs)] // documentation missing in model

    pub fn foo(&self) -> ::std::option::Option<&str> {

        self.foo.as_deref()

    }

}

#[allow(clippy::new_without_default)]

#[allow(clippy::too_many_arguments)]

#[::pyo3::pymethods]

impl ComplexNestedErrorData {

    #[new]

    pub fn new(foo: ::std::option::Option<::std::string::String>) -> Self {

        Self { foo }

    }

    fn __repr__(&self) -> String {

        format!("{self:?}")

    }

    fn __str__(&self) -> String {

        format!("{self:?}")

    }

}

impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ComplexNestedErrorData> {

    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {

        ob.extract::<ComplexNestedErrorData>().map(Box::new)

    }

}

impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ComplexNestedErrorData> {

    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {

        (*self).into_py(py)

    }

}

impl ComplexNestedErrorData {

    /// Creates a new builder-style object to manufacture [`ComplexNestedErrorData`](crate::model::ComplexNestedErrorData).

    pub fn builder() -> crate::model::complex_nested_error_data::Builder {

        crate::model::complex_nested_error_data::Builder::default()

    }

}

#[allow(missing_docs)] // documentation missing in model

///

/// This is a constrained type because its corresponding modeled Smithy shape has one or more

/// [constraint traits]. Use [`IntegerEnumSet::try_from`] to construct values of this type.

///

/// [constraint traits]: https://smithy.io/2.0/spec/constraint-traits.html

///

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub(crate) struct IntegerEnumSet(pub(crate) ::std::vec::Vec<i32>);

impl IntegerEnumSet {

    /// Consumes the value, returning the underlying [`::std::vec::Vec<i32>`].

    pub fn into_inner(self) -> ::std::vec::Vec<i32> {

        self.0

    }

    fn check_unique_items(

        items: ::std::vec::Vec<i32>,

    ) -> ::std::result::Result<

        ::std::vec::Vec<i32>,

        crate::model::integer_enum_set_internal::ConstraintViolation,

    > {

        let mut seen = ::std::collections::HashMap::new();

        let mut duplicate_indices = ::std::vec::Vec::new();

        for (idx, item) in items.iter().enumerate() {

            if let Some(prev_idx) = seen.insert(item, idx) {

                duplicate_indices.push(prev_idx);

            }

        }

        let mut last_duplicate_indices = ::std::vec::Vec::new();

        for idx in &duplicate_indices {

            if let Some(prev_idx) = seen.remove(&items[*idx]) {

                last_duplicate_indices.push(prev_idx);

            }

        }

        duplicate_indices.extend(last_duplicate_indices);

        if !duplicate_indices.is_empty() {

            debug_assert!(duplicate_indices.len() >= 2);

            Err(

                crate::model::integer_enum_set_internal::ConstraintViolation::UniqueItems {

                    duplicate_indices,

                    original: items,

                },

            )

        } else {

            Ok(items)

        }

    }

}

impl ::std::convert::TryFrom<::std::vec::Vec<i32>> for IntegerEnumSet {

    type Error = crate::model::integer_enum_set_internal::ConstraintViolation;

    /// Constructs a `IntegerEnumSet` from an [`::std::vec::Vec<i32>`], failing when the provided value does not satisfy the modeled constraints.

    fn try_from(value: ::std::vec::Vec<i32>) -> ::std::result::Result<Self, Self::Error> {

        let value = Self::check_unique_items(value)?;

        Ok(Self(value))

    }

}

impl ::std::convert::From<IntegerEnumSet> for ::std::vec::Vec<i32> {

    fn from(value: IntegerEnumSet) -> Self {

        value.into_inner()

    }

}

impl crate::constrained::Constrained for IntegerEnumSet {

    type Unconstrained =

        crate::unconstrained::integer_enum_set_unconstrained::IntegerEnumSetUnconstrained;

}

#[allow(missing_docs)] // documentation missing in model

///

/// This is a constrained type because its corresponding modeled Smithy shape has one or more

/// [constraint traits]. Use [`FooEnumSet::try_from`] to construct values of this type.

///

/// [constraint traits]: https://smithy.io/2.0/spec/constraint-traits.html

///

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub(crate) struct FooEnumSet(pub(crate) ::std::vec::Vec<crate::model::FooEnum>);

impl FooEnumSet {

    /// Consumes the value, returning the underlying [`::std::vec::Vec<crate::model::FooEnum>`].

    pub fn into_inner(self) -> ::std::vec::Vec<crate::model::FooEnum> {

        self.0

    }

    fn check_unique_items(

        items: ::std::vec::Vec<crate::model::FooEnum>,

    ) -> ::std::result::Result<

        ::std::vec::Vec<crate::model::FooEnum>,

        crate::model::foo_enum_set_internal::ConstraintViolation,

    > {

        let mut seen = ::std::collections::HashMap::new();

        let mut duplicate_indices = ::std::vec::Vec::new();

        for (idx, item) in items.iter().enumerate() {

            if let Some(prev_idx) = seen.insert(item, idx) {

                duplicate_indices.push(prev_idx);

            }

        }

        let mut last_duplicate_indices = ::std::vec::Vec::new();

        for idx in &duplicate_indices {

            if let Some(prev_idx) = seen.remove(&items[*idx]) {

                last_duplicate_indices.push(prev_idx);

            }

        }

        duplicate_indices.extend(last_duplicate_indices);

        if !duplicate_indices.is_empty() {

            debug_assert!(duplicate_indices.len() >= 2);

            Err(

                crate::model::foo_enum_set_internal::ConstraintViolation::UniqueItems {

                    duplicate_indices,

                    original: items,

                },

            )

        } else {

            Ok(items)

        }

    }

}

impl ::std::convert::TryFrom<::std::vec::Vec<crate::model::FooEnum>> for FooEnumSet {

    type Error = crate::model::foo_enum_set_internal::ConstraintViolation;

    /// Constructs a `FooEnumSet` from an [`::std::vec::Vec<crate::model::FooEnum>`], failing when the provided value does not satisfy the modeled constraints.

    fn try_from(

        value: ::std::vec::Vec<crate::model::FooEnum>,

    ) -> ::std::result::Result<Self, Self::Error> {

        let value = Self::check_unique_items(value)?;

        Ok(Self(value))

    }

}

impl ::std::convert::From<FooEnumSet> for ::std::vec::Vec<crate::model::FooEnum> {

    fn from(value: FooEnumSet) -> Self {

        value.into_inner()

    }

}

impl crate::constrained::Constrained for FooEnumSet {

    type Unconstrained = crate::unconstrained::foo_enum_set_unconstrained::FooEnumSetUnconstrained;

}

#[::pyo3::pyclass]

/// :param blob typing.Optional\[json_rpc11.types.Blob\]:

/// :param boolean typing.Optional\[bool\]:

/// :param double typing.Optional\[float\]:

/// :param empty_struct typing.Optional\[json_rpc11.model.EmptyStruct\]:

/// :param float typing.Optional\[float\]:

/// :param httpdate_timestamp typing.Optional\[json_rpc11.types.DateTime\]:

/// :param integer typing.Optional\[int\]:

/// :param iso8601_timestamp typing.Optional\[json_rpc11.types.DateTime\]:

/// :param json_value typing.Optional\[str\]:

/// :param list_of_lists typing.Optional\[typing.List\[typing.List\[str\]\]\]:

/// :param list_of_maps_of_strings typing.Optional\[typing.List\[typing.Dict\[str, str\]\]\]:

/// :param list_of_strings typing.Optional\[typing.List\[str\]\]:

/// :param list_of_structs typing.Optional\[typing.List\[json_rpc11.model.SimpleStruct\]\]:

/// :param long typing.Optional\[int\]:

/// :param map_of_lists_of_strings typing.Optional\[typing.Dict\[str, typing.List\[str\]\]\]:

/// :param map_of_maps typing.Optional\[typing.Dict\[str, typing.Dict\[str, str\]\]\]:

/// :param map_of_strings typing.Optional\[typing.Dict\[str, str\]\]:

/// :param map_of_structs typing.Optional\[typing.Dict\[str, json_rpc11.model.SimpleStruct\]\]:

/// :param recursive_list typing.Optional\[typing.List\[json_rpc11.model.KitchenSink\]\]:

/// :param recursive_map typing.Optional\[typing.Dict\[str, json_rpc11.model.KitchenSink\]\]:

/// :param recursive_struct typing.Optional\[json_rpc11.model.KitchenSink\]:

/// :param simple_struct typing.Optional\[json_rpc11.model.SimpleStruct\]:

/// :param string typing.Optional\[str\]:

/// :param struct_with_json_name typing.Optional\[json_rpc11.model.StructWithJsonName\]:

/// :param timestamp typing.Optional\[json_rpc11.types.DateTime\]:

/// :param unix_timestamp typing.Optional\[json_rpc11.types.DateTime\]:

/// :rtype None:

#[allow(missing_docs)] // documentation missing in model

#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]

pub struct KitchenSink {

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.types.Blob\]:

    #[allow(missing_docs)] // documentation missing in model

    pub blob: ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[bool\]:

    #[allow(missing_docs)] // documentation missing in model

    pub boolean: ::std::option::Option<bool>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[float\]:

    #[allow(missing_docs)] // documentation missing in model

    pub double: ::std::option::Option<f64>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.model.EmptyStruct\]:

    #[allow(missing_docs)] // documentation missing in model

    pub empty_struct: ::std::option::Option<crate::model::EmptyStruct>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[float\]:

    #[allow(missing_docs)] // documentation missing in model

    pub float: ::std::option::Option<f32>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.types.DateTime\]:

    #[allow(missing_docs)] // documentation missing in model

    pub httpdate_timestamp: ::std::option::Option<::aws_smithy_http_server_python::types::DateTime>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[int\]:

    #[allow(missing_docs)] // documentation missing in model

    pub integer: ::std::option::Option<i32>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.types.DateTime\]:

    #[allow(missing_docs)] // documentation missing in model

    pub iso8601_timestamp: ::std::option::Option<::aws_smithy_http_server_python::types::DateTime>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[str\]:

    #[allow(missing_docs)] // documentation missing in model

    pub json_value: ::std::option::Option<::std::string::String>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.List\[typing.List\[str\]\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub list_of_lists:

        ::std::option::Option<::std::vec::Vec<::std::vec::Vec<::std::string::String>>>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.List\[typing.Dict\[str, str\]\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub list_of_maps_of_strings: ::std::option::Option<

        ::std::vec::Vec<::std::collections::HashMap<::std::string::String, ::std::string::String>>,

    >,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.List\[str\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub list_of_strings: ::std::option::Option<::std::vec::Vec<::std::string::String>>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.List\[json_rpc11.model.SimpleStruct\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub list_of_structs: ::std::option::Option<::std::vec::Vec<crate::model::SimpleStruct>>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[int\]:

    #[allow(missing_docs)] // documentation missing in model

    pub long: ::std::option::Option<i64>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.Dict\[str, typing.List\[str\]\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub map_of_lists_of_strings: ::std::option::Option<

        ::std::collections::HashMap<::std::string::String, ::std::vec::Vec<::std::string::String>>,

    >,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.Dict\[str, typing.Dict\[str, str\]\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub map_of_maps: ::std::option::Option<

        ::std::collections::HashMap<

            ::std::string::String,

            ::std::collections::HashMap<::std::string::String, ::std::string::String>,

        >,

    >,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.Dict\[str, str\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub map_of_strings: ::std::option::Option<

        ::std::collections::HashMap<::std::string::String, ::std::string::String>,

    >,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.Dict\[str, json_rpc11.model.SimpleStruct\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub map_of_structs: ::std::option::Option<

        ::std::collections::HashMap<::std::string::String, crate::model::SimpleStruct>,

    >,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.List\[json_rpc11.model.KitchenSink\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub recursive_list: ::std::option::Option<::std::vec::Vec<crate::model::KitchenSink>>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[typing.Dict\[str, json_rpc11.model.KitchenSink\]\]:

    #[allow(missing_docs)] // documentation missing in model

    pub recursive_map: ::std::option::Option<

        ::std::collections::HashMap<::std::string::String, crate::model::KitchenSink>,

    >,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.model.KitchenSink\]:

    #[allow(missing_docs)] // documentation missing in model

    pub recursive_struct: ::std::option::Option<::std::boxed::Box<crate::model::KitchenSink>>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.model.SimpleStruct\]:

    #[allow(missing_docs)] // documentation missing in model

    pub simple_struct: ::std::option::Option<crate::model::SimpleStruct>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[str\]:

    #[allow(missing_docs)] // documentation missing in model

    pub string: ::std::option::Option<::std::string::String>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.model.StructWithJsonName\]:

    #[allow(missing_docs)] // documentation missing in model

    pub struct_with_json_name: ::std::option::Option<crate::model::StructWithJsonName>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.types.DateTime\]:

    #[allow(missing_docs)] // documentation missing in model

    pub timestamp: ::std::option::Option<::aws_smithy_http_server_python::types::DateTime>,

    #[pyo3(get, set)]

    /// :type typing.Optional\[json_rpc11.types.DateTime\]:

    #[allow(missing_docs)] // documentation missing in model

    pub unix_timestamp: ::std::option::Option<::aws_smithy_http_server_python::types::DateTime>,

}

impl KitchenSink {

    #[allow(missing_docs)] // documentation missing in model

    pub fn blob(&self) -> ::std::option::Option<&::aws_smithy_http_server_python::types::Blob> {

        self.blob.as_ref()

    }

    #[allow(missing_docs)] // documentation missing in model

    pub fn boolean(&self) -> ::std::option::Option<bool> {

        self.boolean

    }

    #[allow(missing_docs)] // documentation missing in model

    pub fn double(&self) -> ::std::option::Option<f64> {

        self.double

    }

    #[allow(missing_docs)] // documentation missing in model

    pub fn empty_struct(&self) -> ::std::option::Option<&crate::model::EmptyStruct> {

        self.empty_struct.as_ref()

    }

    #[allow(missing_docs)] // documentation missing in model

    pub fn float(&self) -> ::std::option::Option<f32> {

        self.float

    }

    #[allow(missing_docs)] // documentation missing in model

    pub fn httpdate_timestamp(

        &self,

    ) -> ::std::option::Option<&::aws_smithy_http_server_python::types::DateTime> {

        self.httpdate_timestamp.as_ref()