Server Test Python

]

[[package]]

name = "async-stream-impl"

version = "0.3.6"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"

dependencies = [

 "proc-macro2",

 "quote",

 "syn 2.0.101",

]

[[package]]

name = "autocfg"

version = "1.4.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"

[[package]]

 "base64 0.21.7",

 "bytes",

 "http 0.2.12",

 "http-body",

 "http-serde",

 "query_map",

 "serde",

 "serde_json",

]

[[package]]

name = "backtrace"

version = "0.3.75"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"

dependencies = [

 "addr2line",

 "cfg-if",

 "libc",

 "miniz_oxide",

}

impl ::std::convert::From<crate::error::InternalServerError>

    for crate::error::ConstrainedShapesOperationError

{

    fn from(

        variant: crate::error::InternalServerError,

    ) -> crate::error::ConstrainedShapesOperationError {

        Self::InternalServerError(variant)

    }

}

impl ::std::convert::From<::pyo3::PyErr> for crate::error::ConstrainedShapesOperationError {

    fn from(variant: ::pyo3::PyErr) -> crate::error::ConstrainedShapesOperationError {

        ::pyo3::Python::with_gil(|py| {

            let error = variant.value(py);

            if let Ok(error) = error.extract::<crate::error::ValidationException>() {

                return error.into();

            }

            crate::error::InternalServerError {

                message: error.to_string(),

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`InternalServerError`](crate::error::InternalServerError).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) message: ::std::option::Option<::std::string::String>,

    }

    impl Builder {

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

        pub fn message(mut self, input: ::std::string::String) -> Self {

            self.message = Some(input);

            self

    /// A builder for [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) message_content: ::std::option::Option<::std::string::String>,

    }

    impl Builder {

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

        pub fn message_content(

            mut self,

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

        ) -> Self {

            self.message_content = input;

            self

        }

        /// Consumes the builder and constructs a [`EventStreamErrorMessage`](crate::error::EventStreamErrorMessage).

        pub fn build(self) -> crate::error::EventStreamErrorMessage {

            self.build_enforcing_required_and_enum_traits()

        }

        fn build_enforcing_required_and_enum_traits(self) -> crate::error::EventStreamErrorMessage {

            crate::error::EventStreamErrorMessage {

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ValidationException`](crate::error::ValidationException).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) message: ::std::option::Option<::std::string::String>,

        pub(crate) field_list:

            ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,

    }

    impl Builder {

        /// A summary of the validation failure.

        pub fn message(mut self, input: ::std::string::String) -> Self {

            input: impl ::std::convert::Into<

                crate::python_event_stream::EventStreamsOperationInputEventsReceiver,

            >,

        ) -> Self {

            self.events = Some(input.into());

            self

        }

        /// Consumes the builder and constructs a [`EventStreamsOperationInput`](crate::input::EventStreamsOperationInput).

        ///

        /// The builder fails to construct a [`EventStreamsOperationInput`](crate::input::EventStreamsOperationInput) if a [`ConstraintViolation`] occurs.

        ///

        pub fn build(

            self,

        ) -> Result<crate::input::EventStreamsOperationInput, ConstraintViolation> {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(

            self,

        ) -> Result<crate::input::EventStreamsOperationInput, ConstraintViolation> {

            Ok(crate::input::EventStreamsOperationInput {

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::input::EventStreamsOperationInput {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`EventStreamsOperationInput`](crate::input::EventStreamsOperationInput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) events: ::std::option::Option<

            crate::python_event_stream::EventStreamsOperationInputEventsReceiver,

        >,

    }

    impl Builder {

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

        pub fn events(

            Ok(crate::input::ConstrainedRecursiveShapesOperationInput {

                nested: self

                    .nested

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::Nested))

                    .transpose()?,

                recursive_list: self

                    .recursive_list

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| {

                        res.map(|v| v.into())

                            .map_err(ConstraintViolation::RecursiveList)

                    })

                    .transpose()?

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::input::ConstrainedRecursiveShapesOperationInput {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ConstrainedRecursiveShapesOperationInput`](crate::input::ConstrainedRecursiveShapesOperationInput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) nested: ::std::option::Option<crate::model::RecursiveShapesInputOutputNested1>,

        pub(crate) recursive_list:

            ::std::option::Option<::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>>,

    }

    impl Builder {

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

        pub fn nested(

        {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(

            self,

        ) -> Result<crate::input::ConstrainedHttpPayloadBoundShapeOperationInput, ConstraintViolation>

        {

            Ok(

                crate::input::ConstrainedHttpPayloadBoundShapeOperationInput {

                    http_payload_bound_constrained_shape: self

                        .http_payload_bound_constrained_shape

                        .map(|v| match v {

                            crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                            crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                        })

                        .map(|res| {

                            res.map_err(ConstraintViolation::HttpPayloadBoundConstrainedShape)

                        })

                        .transpose()?

                        .ok_or(ConstraintViolation::MissingHttpPayloadBoundConstrainedShape)?,

        }

    }

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

    impl ::std::convert::TryFrom<Builder>

        for crate::input::ConstrainedHttpPayloadBoundShapeOperationInput

    {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ConstrainedHttpPayloadBoundShapeOperationInput`](crate::input::ConstrainedHttpPayloadBoundShapeOperationInput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) http_payload_bound_constrained_shape: ::std::option::Option<crate::model::ConA>,

    }

    impl Builder {

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

        pub fn http_payload_bound_constrained_shape(mut self, input: crate::model::ConA) -> Self {

                    .map(|v: crate::model::SetOfRangeInteger| v.into()),

                range_long_set_query: self

                    .range_long_set_query

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::RangeLongSetQuery))

                    .transpose()?

                    .map(|v: crate::model::SetOfRangeLong| v.into()),

                enum_string_list_query: self

                    .enum_string_list_query

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| {

                        res.map(|v| v.into())

                            .map_err(ConstraintViolation::EnumStringListQuery)

                    })

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

            match self {

                ConstraintViolation::MissingLengthStringLabel => write!(f, "`length_string_label` was not provided but it is required when building `ConstrainedHttpBoundShapesOperationInput`"),

                ConstraintViolation::MissingEnumStringLabel => write!(f, "`enum_string_label` was not provided but it is required when building `ConstrainedHttpBoundShapesOperationInput`"),

                ConstraintViolation::MissingLengthStringHeaderMap => write!(f, "`length_string_header_map` was not provided but it is required when building `ConstrainedHttpBoundShapesOperationInput`"),

            }

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::input::ConstrainedHttpBoundShapesOperationInput {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ConstrainedHttpBoundShapesOperationInput`](crate::input::ConstrainedHttpBoundShapesOperationInput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) length_string_label: ::std::option::Option<::std::string::String>,

        /// The builder fails to construct a [`ConstrainedShapesOperationInput`](crate::input::ConstrainedShapesOperationInput) if a [`ConstraintViolation`] occurs.

        ///

        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].

        pub fn build(

            self,

        ) -> Result<crate::input::ConstrainedShapesOperationInput, ConstraintViolation> {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(

            self,

        ) -> Result<crate::input::ConstrainedShapesOperationInput, ConstraintViolation> {

            Ok(crate::input::ConstrainedShapesOperationInput {

                con_a: self

                    .con_a

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::ConA))

                    .transpose()?

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::input::ConstrainedShapesOperationInput {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ConstrainedShapesOperationInput`](crate::input::ConstrainedShapesOperationInput).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) con_a: ::std::option::Option<crate::model::ConA>,

    }

    impl Builder {

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

        pub fn con_a(mut self, input: crate::model::ConA) -> Self {

            self.con_a = Some(input);

            self

    }

}

impl ::std::convert::TryFrom<::std::vec::Vec<crate::model::ConstrainedUnionInOutput>>

    for ConstrainedListInOutput

{

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

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

    fn try_from(

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

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

        Self::check_length(value.len())?;

        Ok(Self(value))

    }

}

impl ::std::convert::From<ConstrainedListInOutput>

    for ::std::vec::Vec<crate::model::ConstrainedUnionInOutput>

{

                ConstraintViolation::MissingPath => write!(f, "`path` was not provided but it is required when building `ValidationExceptionField`"),

                ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationExceptionField`"),

            }

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::model::ValidationExceptionField {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ValidationExceptionField`](crate::model::ValidationExceptionField).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) path: ::std::option::Option<::std::string::String>,

        pub(crate) message: ::std::option::Option<::std::string::String>,

    }

    impl Builder {

        ) -> Result<crate::model::RecursiveShapesInputOutputNested1, ConstraintViolation> {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(

            self,

        ) -> Result<crate::model::RecursiveShapesInputOutputNested1, ConstraintViolation> {

            Ok(crate::model::RecursiveShapesInputOutputNested1 {

                recursive_member: self

                    .recursive_member

                    .map(|v| match *v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(Box::new(x)),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => {

                            Ok(Box::new(x.try_into()?))

                        }

                    })

                    .map(|res| {

                        res.map_err(Box::new)

                            .map_err(ConstraintViolation::RecursiveMember)

                    })

                    .transpose()?

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::model::RecursiveShapesInputOutputNested1 {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`RecursiveShapesInputOutputNested1`](crate::model::RecursiveShapesInputOutputNested1).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) recursive_member: ::std::option::Option<

            ::std::boxed::Box<crate::model::RecursiveShapesInputOutputNested2>,

        >,

    }

    impl Builder {

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

        pub fn recursive_member(

                    .map(|res| res.map_err(ConstraintViolation::SetOfLengthPatternString))

                    .transpose()?

                    .map(|v: crate::model::SetOfLengthPatternString| v.into()),

                length_list_of_pattern_string: self

                    .length_list_of_pattern_string

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::LengthListOfPatternString))

                    .transpose()?

                    .map(|v: crate::model::LengthListOfPatternString| v.into()),

                length_set_of_pattern_string: self

                    .length_set_of_pattern_string

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::LengthSetOfPatternString))

                    .transpose()?

                    "`con_b` was not provided but it is required when building `ConA`"

                ),

            }

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::model::ConA {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ConA`](crate::model::ConA).

    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]

    pub struct Builder {

        pub(crate) con_b: ::std::option::Option<crate::model::ConB>,

        pub(crate) opt_con_b: ::std::option::Option<crate::model::ConB>,

        pub(crate) length_string: ::std::option::Option<::std::string::String>,

        pub(crate) min_length_string: ::std::option::Option<::std::string::String>,

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

        pub(crate) fn set_opt_int(mut self, input: Option<impl ::std::convert::Into<i32>>) -> Self {

            self.opt_int = input.map(|v| v.into());

            self

        }

        /// Consumes the builder and constructs a [`ConB`](crate::model::ConB).

        ///

        /// The builder fails to construct a [`ConB`](crate::model::ConB) if a [`ConstraintViolation`] occurs.

        ///

        /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].

        pub fn build(self) -> Result<crate::model::ConB, ConstraintViolation> {

            self.build_enforcing_all_constraints()

        }

        fn build_enforcing_all_constraints(

            self,

        ) -> Result<crate::model::ConB, ConstraintViolation> {

            Ok(crate::model::ConB {

                nice: self.nice.ok_or(ConstraintViolation::MissingNice)?,

                int: self.int.ok_or(ConstraintViolation::MissingInt)?,

                opt_nice: self.opt_nice,

                ConstraintViolation::MissingNice => write!(

                    f,

                    "`nice` was not provided but it is required when building `ConB`"

                ),

                ConstraintViolation::MissingInt => write!(

                    f,

                    "`int` was not provided but it is required when building `ConB`"

                ),

            }

        }

    }

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

    impl ::std::convert::TryFrom<Builder> for crate::model::ConB {

        type Error = ConstraintViolation;

        fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

            builder.build()

        }

    }

    /// A builder for [`ConB`](crate::model::ConB).

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::EventStreamsOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B: Into<::aws_smithy_types::byte_stream::ByteStream>,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

    type Future = EventStreamsOperationInputFuture;

        EventStreamsOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

    > for crate::output::EventStreamsOperationOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_event_streams_operation::ser_event_streams_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::StreamingBlobOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B: Into<::aws_smithy_types::byte_stream::ByteStream>,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

    type Future = StreamingBlobOperationInputFuture;

        StreamingBlobOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

    > for crate::output::StreamingBlobOperationOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_streaming_blob_operation::ser_streaming_blob_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::NonStreamingBlobOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B::Data: Send,

        NonStreamingBlobOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

    > for crate::output::NonStreamingBlobOperationOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_non_streaming_blob_operation::ser_non_streaming_blob_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::QueryParamsTargetingMapOfEnumStringOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

    type Future = QueryParamsTargetingMapOfEnumStringOperationInputFuture;

        QueryParamsTargetingMapOfEnumStringOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

    > for crate::output::QueryParamsTargetingMapOfEnumStringOperationOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_query_params_targeting_map_of_enum_string_operation::ser_query_params_targeting_map_of_enum_string_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

    type Future = HttpPrefixHeadersTargetingLengthMapOperationInputFuture;

        HttpPrefixHeadersTargetingLengthMapOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

    > for crate::output::HttpPrefixHeadersTargetingLengthMapOperationOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_http_prefix_headers_targeting_length_map_operation::ser_http_prefix_headers_targeting_length_map_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::QueryParamsTargetingMapOfListOfLengthPatternStringOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

    type Future = QueryParamsTargetingMapOfListOfLengthPatternStringOperationInputFuture;

        QueryParamsTargetingMapOfListOfLengthPatternStringOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    ::aws_smithy_http_server::response::IntoResponse<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

    > for crate::output::QueryParamsTargetingMapOfListOfLengthPatternStringOperationOutput

{

    fn into_response(self) -> ::aws_smithy_http_server::response::Response {

        match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_pattern_string_operation::ser_query_params_targeting_map_of_list_of_length_pattern_string_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                            ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))

                        }

                    }

    }

}

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

    ::aws_smithy_http_server::request::FromRequest<

        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

        B,

    > for crate::input::QueryParamsTargetingMapOfLengthPatternStringOperationInput

where

    B: ::aws_smithy_http_server::body::HttpBody + Send,

    B: 'static,

    B::Data: Send,

    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:

        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

{

    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

    type Future = QueryParamsTargetingMapOfLengthPatternStringOperationInputFuture;