Server Test Python

Server Test Python

rev. 0b749be6d000fdc7ef59d1bc26f1dce00358d95c (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/src/operation.rs

@@ -1,1 +31,331 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
const CONTENT_TYPE_OPERATIONWITHNESTEDSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
           3  +
::pin_project_lite::pin_project! {
           4  +
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
           5  +
    /// [`OperationWithNestedStructureInput`](crate::input::OperationWithNestedStructureInput) using modelled bindings.
           6  +
    pub struct OperationWithNestedStructureInputFuture {
           7  +
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationWithNestedStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
           8  +
    }
           9  +
}
          10  +
          11  +
impl std::future::Future for OperationWithNestedStructureInputFuture {
          12  +
    type Output = Result<
          13  +
        crate::input::OperationWithNestedStructureInput,
          14  +
        ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
          15  +
    >;
          16  +
          17  +
    fn poll(
          18  +
        self: std::pin::Pin<&mut Self>,
          19  +
        cx: &mut std::task::Context<'_>,
          20  +
    ) -> std::task::Poll<Self::Output> {
          21  +
        let this = self.project();
          22  +
        this.inner.as_mut().poll(cx)
          23  +
    }
          24  +
}
          25  +
          26  +
impl<B>
          27  +
    ::aws_smithy_http_server::request::FromRequest<
          28  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
          29  +
        B,
          30  +
    > for crate::input::OperationWithNestedStructureInput
          31  +
where
          32  +
    B: ::aws_smithy_http_server::body::HttpBody + Send,
          33  +
    B: 'static,
          34  +
          35  +
    B::Data: Send,
          36  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
          37  +
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
          38  +
{
          39  +
    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
          40  +
    type Future = OperationWithNestedStructureInputFuture;
          41  +
          42  +
    fn from_request(request: ::http::Request<B>) -> Self::Future {
          43  +
        let fut = async move {
          44  +
            if !::aws_smithy_http_server::protocol::accept_header_classifier(
          45  +
                request.headers(),
          46  +
                &CONTENT_TYPE_OPERATIONWITHNESTEDSTRUCTURE,
          47  +
            ) {
          48  +
                return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
          49  +
            }
          50  +
            crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_http_request(request)
          51  +
                            .await
          52  +
                            .map_err(Into::into)
          53  +
        };
          54  +
        use ::futures_util::future::TryFutureExt;
          55  +
        let fut = fut.map_err(
          56  +
            |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
          57  +
                ::tracing::debug!(error = %e, "failed to deserialize request");
          58  +
                ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
          59  +
                    e,
          60  +
                )
          61  +
            },
          62  +
        );
          63  +
        OperationWithNestedStructureInputFuture {
          64  +
            inner: Box::pin(fut),
          65  +
        }
          66  +
    }
          67  +
}
          68  +
impl
          69  +
    ::aws_smithy_http_server::response::IntoResponse<
          70  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
          71  +
    > for crate::output::OperationWithNestedStructureOutput
          72  +
{
          73  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
          74  +
        match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_response(self) {
          75  +
                        Ok(response) => response,
          76  +
                        Err(e) => {
          77  +
                            ::tracing::error!(error = %e, "failed to serialize response");
          78  +
                            ::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))
          79  +
                        }
          80  +
                    }
          81  +
    }
          82  +
}
          83  +
impl
          84  +
    ::aws_smithy_http_server::response::IntoResponse<
          85  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
          86  +
    > for crate::error::OperationWithNestedStructureError
          87  +
{
          88  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
          89  +
        match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_error(&self) {
          90  +
            Ok(mut response) => {
          91  +
                response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
          92  +
                response
          93  +
            },
          94  +
            Err(e) => {
          95  +
                ::tracing::error!(error = %e, "failed to serialize response");
          96  +
                ::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))
          97  +
            }
          98  +
        }
          99  +
    }
         100  +
}
         101  +
         102  +
const CONTENT_TYPE_OPERATIONWITHDEFAULTS: ::mime::Mime = ::mime::APPLICATION_JSON;
         103  +
::pin_project_lite::pin_project! {
         104  +
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
         105  +
    /// [`OperationWithDefaultsInput`](crate::input::OperationWithDefaultsInput) using modelled bindings.
         106  +
    pub struct OperationWithDefaultsInputFuture {
         107  +
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationWithDefaultsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         108  +
    }
         109  +
}
         110  +
         111  +
impl std::future::Future for OperationWithDefaultsInputFuture {
         112  +
    type Output = Result<
         113  +
        crate::input::OperationWithDefaultsInput,
         114  +
        ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         115  +
    >;
         116  +
         117  +
    fn poll(
         118  +
        self: std::pin::Pin<&mut Self>,
         119  +
        cx: &mut std::task::Context<'_>,
         120  +
    ) -> std::task::Poll<Self::Output> {
         121  +
        let this = self.project();
         122  +
        this.inner.as_mut().poll(cx)
         123  +
    }
         124  +
}
         125  +
         126  +
impl<B>
         127  +
    ::aws_smithy_http_server::request::FromRequest<
         128  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         129  +
        B,
         130  +
    > for crate::input::OperationWithDefaultsInput
         131  +
where
         132  +
    B: ::aws_smithy_http_server::body::HttpBody + Send,
         133  +
    B: 'static,
         134  +
         135  +
    B::Data: Send,
         136  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         137  +
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
         138  +
{
         139  +
    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
         140  +
    type Future = OperationWithDefaultsInputFuture;
         141  +
         142  +
    fn from_request(request: ::http::Request<B>) -> Self::Future {
         143  +
        let fut = async move {
         144  +
            if !::aws_smithy_http_server::protocol::accept_header_classifier(
         145  +
                request.headers(),
         146  +
                &CONTENT_TYPE_OPERATIONWITHDEFAULTS,
         147  +
            ) {
         148  +
                return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
         149  +
            }
         150  +
            crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_request(request)
         151  +
                            .await
         152  +
                            .map_err(Into::into)
         153  +
        };
         154  +
        use ::futures_util::future::TryFutureExt;
         155  +
        let fut = fut.map_err(
         156  +
            |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
         157  +
                ::tracing::debug!(error = %e, "failed to deserialize request");
         158  +
                ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
         159  +
                    e,
         160  +
                )
         161  +
            },
         162  +
        );
         163  +
        OperationWithDefaultsInputFuture {
         164  +
            inner: Box::pin(fut),
         165  +
        }
         166  +
    }
         167  +
}
         168  +
impl
         169  +
    ::aws_smithy_http_server::response::IntoResponse<
         170  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         171  +
    > for crate::output::OperationWithDefaultsOutput
         172  +
{
         173  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         174  +
        match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
         175  +
                        Ok(response) => response,
         176  +
                        Err(e) => {
         177  +
                            ::tracing::error!(error = %e, "failed to serialize response");
         178  +
                            ::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))
         179  +
                        }
         180  +
                    }
         181  +
    }
         182  +
}
         183  +
impl
         184  +
    ::aws_smithy_http_server::response::IntoResponse<
         185  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         186  +
    > for crate::error::OperationWithDefaultsError
         187  +
{
         188  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         189  +
        match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_error(&self) {
         190  +
            Ok(mut response) => {
         191  +
                response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
         192  +
                response
         193  +
            },
         194  +
            Err(e) => {
         195  +
                ::tracing::error!(error = %e, "failed to serialize response");
         196  +
                ::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))
         197  +
            }
         198  +
        }
         199  +
    }
         200  +
}
         201  +
         202  +
const CONTENT_TYPE_CONTENTTYPEPARAMETERS: ::mime::Mime = ::mime::APPLICATION_JSON;
         203  +
::pin_project_lite::pin_project! {
         204  +
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
         205  +
    /// [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput) using modelled bindings.
         206  +
    pub struct ContentTypeParametersInputFuture {
         207  +
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ContentTypeParametersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         208  +
    }
         209  +
}
         210  +
         211  +
impl std::future::Future for ContentTypeParametersInputFuture {
         212  +
    type Output = Result<
         213  +
        crate::input::ContentTypeParametersInput,
         214  +
        ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         215  +
    >;
         216  +
         217  +
    fn poll(
         218  +
        self: std::pin::Pin<&mut Self>,
         219  +
        cx: &mut std::task::Context<'_>,
         220  +
    ) -> std::task::Poll<Self::Output> {
         221  +
        let this = self.project();
         222  +
        this.inner.as_mut().poll(cx)
         223  +
    }
         224  +
}
         225  +
         226  +
impl<B>
         227  +
    ::aws_smithy_http_server::request::FromRequest<
         228  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         229  +
        B,
         230  +
    > for crate::input::ContentTypeParametersInput
         231  +
where
         232  +
    B: ::aws_smithy_http_server::body::HttpBody + Send,
         233  +
    B: 'static,
         234  +
         235  +
    B::Data: Send,
         236  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         237  +
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
         238  +
{
         239  +
    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
         240  +
    type Future = ContentTypeParametersInputFuture;
         241  +
         242  +
    fn from_request(request: ::http::Request<B>) -> Self::Future {
         243  +
        let fut = async move {
         244  +
            if !::aws_smithy_http_server::protocol::accept_header_classifier(
         245  +
                request.headers(),
         246  +
                &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
         247  +
            ) {
         248  +
                return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
         249  +
            }
         250  +
            crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
         251  +
                            .await
         252  +
                            .map_err(Into::into)
         253  +
        };
         254  +
        use ::futures_util::future::TryFutureExt;
         255  +
        let fut = fut.map_err(
         256  +
            |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
         257  +
                ::tracing::debug!(error = %e, "failed to deserialize request");
         258  +
                ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
         259  +
                    e,
         260  +
                )
         261  +
            },
         262  +
        );
         263  +
        ContentTypeParametersInputFuture {
         264  +
            inner: Box::pin(fut),
         265  +
        }
         266  +
    }
         267  +
}
         268  +
impl
         269  +
    ::aws_smithy_http_server::response::IntoResponse<
         270  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         271  +
    > for crate::output::ContentTypeParametersOutput
         272  +
{
         273  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         274  +
        match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
         275  +
                        Ok(response) => response,
         276  +
                        Err(e) => {
         277  +
                            ::tracing::error!(error = %e, "failed to serialize response");
         278  +
                            ::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))
         279  +
                        }
         280  +
                    }
         281  +
    }
         282  +
}
         283  +
impl
         284  +
    ::aws_smithy_http_server::response::IntoResponse<
         285  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         286  +
    > for crate::error::ContentTypeParametersError
         287  +
{
         288  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         289  +
        match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_error(&self) {
         290  +
            Ok(mut response) => {
         291  +
                response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
         292  +
                response
         293  +
            },
         294  +
            Err(e) => {
         295  +
                ::tracing::error!(error = %e, "failed to serialize response");
         296  +
                ::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))
         297  +
            }
         298  +
        }
         299  +
    }
         300  +
}
         301  +
    2    302   
const CONTENT_TYPE_PUTWITHCONTENTENCODING: ::mime::Mime = ::mime::APPLICATION_JSON;
    3    303   
::pin_project_lite::pin_project! {
    4    304   
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
    5    305   
    /// [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput) using modelled bindings.
    6    306   
    pub struct PutWithContentEncodingInputFuture {
    7    307   
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PutWithContentEncodingInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
    8    308   
    }
    9    309   
}
   10    310   
   11    311   
impl std::future::Future for PutWithContentEncodingInputFuture {
@@ -285,585 +344,744 @@
  305    605   
                response
  306    606   
            }
  307    607   
            Err(e) => {
  308    608   
                ::tracing::error!(error = %e, "failed to serialize response");
  309    609   
                ::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))
  310    610   
            }
  311    611   
        }
  312    612   
    }
  313    613   
}
  314    614   
         615  +
const CONTENT_TYPE_TESTNOINPUTNOPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
         616  +
::pin_project_lite::pin_project! {
         617  +
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
         618  +
    /// [`TestNoInputNoPayloadInput`](crate::input::TestNoInputNoPayloadInput) using modelled bindings.
         619  +
    pub struct TestNoInputNoPayloadInputFuture {
         620  +
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestNoInputNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         621  +
    }
         622  +
}
         623  +
         624  +
impl std::future::Future for TestNoInputNoPayloadInputFuture {
         625  +
    type Output = Result<
         626  +
        crate::input::TestNoInputNoPayloadInput,
         627  +
        ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         628  +
    >;
         629  +
         630  +
    fn poll(
         631  +
        self: std::pin::Pin<&mut Self>,
         632  +
        cx: &mut std::task::Context<'_>,
         633  +
    ) -> std::task::Poll<Self::Output> {
         634  +
        let this = self.project();
         635  +
        this.inner.as_mut().poll(cx)
         636  +
    }
         637  +
}
         638  +
         639  +
impl<B>
         640  +
    ::aws_smithy_http_server::request::FromRequest<
         641  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         642  +
        B,
         643  +
    > for crate::input::TestNoInputNoPayloadInput
         644  +
where
         645  +
    B: ::aws_smithy_http_server::body::HttpBody + Send,
         646  +
    B: 'static,
         647  +
         648  +
    B::Data: Send,
         649  +
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         650  +
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
         651  +
{
         652  +
    type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
         653  +
    type Future = TestNoInputNoPayloadInputFuture;
         654  +
         655  +
    fn from_request(request: ::http::Request<B>) -> Self::Future {
         656  +
        let fut = async move {
         657  +
            if !::aws_smithy_http_server::protocol::accept_header_classifier(
         658  +
                request.headers(),
         659  +
                &CONTENT_TYPE_TESTNOINPUTNOPAYLOAD,
         660  +
            ) {
         661  +
                return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
         662  +
            }
         663  +
            crate::protocol_serde::shape_test_no_input_no_payload::de_test_no_input_no_payload_http_request(request)
         664  +
                            .await
         665  +
                            .map_err(Into::into)
         666  +
        };
         667  +
        use ::futures_util::future::TryFutureExt;
         668  +
        let fut = fut.map_err(
         669  +
            |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
         670  +
                ::tracing::debug!(error = %e, "failed to deserialize request");
         671  +
                ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
         672  +
                    e,
         673  +
                )
         674  +
            },
         675  +
        );
         676  +
        TestNoInputNoPayloadInputFuture {
         677  +
            inner: Box::pin(fut),
         678  +
        }
         679  +
    }
         680  +
}
         681  +
impl
         682  +
    ::aws_smithy_http_server::response::IntoResponse<
         683  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         684  +
    > for crate::output::TestNoInputNoPayloadOutput
         685  +
{
         686  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         687  +
        match crate::protocol_serde::shape_test_no_input_no_payload::ser_test_no_input_no_payload_http_response(self) {
         688  +
                        Ok(response) => response,
         689  +
                        Err(e) => {
         690  +
                            ::tracing::error!(error = %e, "failed to serialize response");
         691  +
                            ::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))
         692  +
                        }
         693  +
                    }
         694  +
    }
         695  +
}
         696  +
impl
         697  +
    ::aws_smithy_http_server::response::IntoResponse<
         698  +
        ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         699  +
    > for crate::error::TestNoInputNoPayloadError
         700  +
{
         701  +
    fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         702  +
        match crate::protocol_serde::shape_test_no_input_no_payload::ser_test_no_input_no_payload_http_error(&self) {
         703  +
            Ok(mut response) => {
         704  +
                response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
         705  +
                response
         706  +
            },
         707  +
            Err(e) => {
         708  +
                ::tracing::error!(error = %e, "failed to serialize response");
         709  +
                ::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))
         710  +
            }
         711  +
        }
         712  +
    }
         713  +
}
         714  +
  315    715   
const CONTENT_TYPE_TESTNOPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
  316    716   
::pin_project_lite::pin_project! {
  317    717   
    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
  318    718   
    /// [`TestNoPayloadInput`](crate::input::TestNoPayloadInput) using modelled bindings.
  319    719   
    pub struct TestNoPayloadInputFuture {
  320    720   
        inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
  321    721   
    }
  322    722   
}
  323    723   
  324    724   
impl std::future::Future for TestNoPayloadInputFuture {

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/src/operation_shape.rs

@@ -1,1 +31,147 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(missing_docs)] // documentation missing in model
           3  +
pub struct OperationWithNestedStructure;
           4  +
           5  +
impl ::aws_smithy_http_server::operation::OperationShape for OperationWithNestedStructure {
           6  +
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
           7  +
        ::aws_smithy_http_server::shape_id::ShapeId::new(
           8  +
            "aws.protocoltests.restjson#OperationWithNestedStructure",
           9  +
            "aws.protocoltests.restjson",
          10  +
            "OperationWithNestedStructure",
          11  +
        );
          12  +
          13  +
    type Input = crate::input::OperationWithNestedStructureInput;
          14  +
    type Output = crate::output::OperationWithNestedStructureOutput;
          15  +
    type Error = crate::error::OperationWithNestedStructureError;
          16  +
}
          17  +
          18  +
impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity
          19  +
    for OperationWithNestedStructure
          20  +
{
          21  +
    type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
          22  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          23  +
        ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
          24  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
          25  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
          26  +
        >,
          27  +
    >;
          28  +
    type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
          29  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          30  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          31  +
    >;
          32  +
          33  +
    fn request_fmt() -> Self::RequestFmt {
          34  +
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
          35  +
    }
          36  +
          37  +
    fn response_fmt() -> Self::ResponseFmt {
          38  +
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
          39  +
    }
          40  +
}
          41  +
          42  +
#[allow(missing_docs)] // documentation missing in model
          43  +
pub struct OperationWithDefaults;
          44  +
          45  +
impl ::aws_smithy_http_server::operation::OperationShape for OperationWithDefaults {
          46  +
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
          47  +
        ::aws_smithy_http_server::shape_id::ShapeId::new(
          48  +
            "aws.protocoltests.restjson#OperationWithDefaults",
          49  +
            "aws.protocoltests.restjson",
          50  +
            "OperationWithDefaults",
          51  +
        );
          52  +
          53  +
    type Input = crate::input::OperationWithDefaultsInput;
          54  +
    type Output = crate::output::OperationWithDefaultsOutput;
          55  +
    type Error = crate::error::OperationWithDefaultsError;
          56  +
}
          57  +
          58  +
impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for OperationWithDefaults {
          59  +
    type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
          60  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          61  +
        ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
          62  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
          63  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
          64  +
        >,
          65  +
    >;
          66  +
    type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
          67  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          68  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          69  +
    >;
          70  +
          71  +
    fn request_fmt() -> Self::RequestFmt {
          72  +
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
          73  +
    }
          74  +
          75  +
    fn response_fmt() -> Self::ResponseFmt {
          76  +
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
          77  +
    }
          78  +
}
          79  +
          80  +
/// The example tests how servers must support requests containing a `Content-Type` header with parameters.
          81  +
pub struct ContentTypeParameters;
          82  +
          83  +
impl ::aws_smithy_http_server::operation::OperationShape for ContentTypeParameters {
          84  +
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
          85  +
        ::aws_smithy_http_server::shape_id::ShapeId::new(
          86  +
            "aws.protocoltests.restjson#ContentTypeParameters",
          87  +
            "aws.protocoltests.restjson",
          88  +
            "ContentTypeParameters",
          89  +
        );
          90  +
          91  +
    type Input = crate::input::ContentTypeParametersInput;
          92  +
    type Output = crate::output::ContentTypeParametersOutput;
          93  +
    type Error = crate::error::ContentTypeParametersError;
          94  +
}
          95  +
          96  +
impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for ContentTypeParameters {
          97  +
    type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
          98  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
          99  +
        ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
         100  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
         101  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
         102  +
        >,
         103  +
    >;
         104  +
    type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         105  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         106  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         107  +
    >;
         108  +
         109  +
    fn request_fmt() -> Self::RequestFmt {
         110  +
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
         111  +
    }
         112  +
         113  +
    fn response_fmt() -> Self::ResponseFmt {
         114  +
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
         115  +
    }
         116  +
}
         117  +
    2    118   
#[allow(missing_docs)] // documentation missing in model
    3    119   
pub struct PutWithContentEncoding;
    4    120   
    5    121   
impl ::aws_smithy_http_server::operation::OperationShape for PutWithContentEncoding {
    6    122   
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
    7    123   
        ::aws_smithy_http_server::shape_id::ShapeId::new(
    8    124   
            "aws.protocoltests.restjson#PutWithContentEncoding",
    9    125   
            "aws.protocoltests.restjson",
   10    126   
            "PutWithContentEncoding",
   11    127   
        );
@@ -88,204 +147,301 @@
  108    224   
  109    225   
    fn request_fmt() -> Self::RequestFmt {
  110    226   
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
  111    227   
    }
  112    228   
  113    229   
    fn response_fmt() -> Self::ResponseFmt {
  114    230   
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
  115    231   
    }
  116    232   
}
  117    233   
         234  +
/// This example operation has no input and serializes a request without an HTTP body. These tests are to ensure we do not attach a body or related headers (Content-Length, Content-Type) to operations that semantically cannot produce an HTTP body.
         235  +
pub struct TestNoInputNoPayload;
         236  +
         237  +
impl ::aws_smithy_http_server::operation::OperationShape for TestNoInputNoPayload {
         238  +
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         239  +
        ::aws_smithy_http_server::shape_id::ShapeId::new(
         240  +
            "aws.protocoltests.restjson#TestNoInputNoPayload",
         241  +
            "aws.protocoltests.restjson",
         242  +
            "TestNoInputNoPayload",
         243  +
        );
         244  +
         245  +
    type Input = crate::input::TestNoInputNoPayloadInput;
         246  +
    type Output = crate::output::TestNoInputNoPayloadOutput;
         247  +
    type Error = crate::error::TestNoInputNoPayloadError;
         248  +
}
         249  +
         250  +
impl ::aws_smithy_http_server::instrumentation::sensitivity::Sensitivity for TestNoInputNoPayload {
         251  +
    type RequestFmt = ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt<
         252  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         253  +
        ::aws_smithy_http_server::instrumentation::sensitivity::uri::MakeUri<
         254  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
         255  +
            ::aws_smithy_http_server::instrumentation::MakeIdentity,
         256  +
        >,
         257  +
    >;
         258  +
    type ResponseFmt = ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt<
         259  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         260  +
        ::aws_smithy_http_server::instrumentation::MakeIdentity,
         261  +
    >;
         262  +
         263  +
    fn request_fmt() -> Self::RequestFmt {
         264  +
        ::aws_smithy_http_server::instrumentation::sensitivity::RequestFmt::new()
         265  +
    }
         266  +
         267  +
    fn response_fmt() -> Self::ResponseFmt {
         268  +
        ::aws_smithy_http_server::instrumentation::sensitivity::ResponseFmt::new()
         269  +
    }
         270  +
}
         271  +
  118    272   
/// This example operation serializes a request without an HTTP body. These tests are to ensure we do not attach a body or related headers (Content-Length, Content-Type) to operations that semantically cannot produce an HTTP body.
  119    273   
pub struct TestNoPayload;
  120    274   
  121    275   
impl ::aws_smithy_http_server::operation::OperationShape for TestNoPayload {
  122    276   
    const ID: ::aws_smithy_http_server::shape_id::ShapeId =
  123    277   
        ::aws_smithy_http_server::shape_id::ShapeId::new(
  124    278   
            "aws.protocoltests.restjson#TestNoPayload",
  125    279   
            "aws.protocoltests.restjson",
  126    280   
            "TestNoPayload",
  127    281   
        );

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/src/output.rs

@@ -1,1 +31,514 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[::pyo3::pyclass]
           3  +
/// :param dialog rest_json.model.Dialog:
           4  +
/// :param dialog_list typing.List\[rest_json.model.Dialog\]:
           5  +
/// :param dialog_map typing.Dict\[str, rest_json.model.Dialog\]:
           6  +
/// :rtype None:
           7  +
#[allow(missing_docs)] // documentation missing in model
           8  +
#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           9  +
pub struct OperationWithNestedStructureOutput {
          10  +
    #[pyo3(get, set)]
          11  +
    /// :type rest_json.model.Dialog:
          12  +
    #[allow(missing_docs)] // documentation missing in model
          13  +
    pub dialog: crate::model::Dialog,
          14  +
    #[pyo3(get, set)]
          15  +
    /// :type typing.List\[rest_json.model.Dialog\]:
          16  +
    #[allow(missing_docs)] // documentation missing in model
          17  +
    pub dialog_list: ::std::vec::Vec<crate::model::Dialog>,
          18  +
    #[pyo3(get, set)]
          19  +
    /// :type typing.Dict\[str, rest_json.model.Dialog\]:
          20  +
    #[allow(missing_docs)] // documentation missing in model
          21  +
    pub dialog_map: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
          22  +
}
          23  +
impl OperationWithNestedStructureOutput {
          24  +
    #[allow(missing_docs)] // documentation missing in model
          25  +
    pub fn dialog(&self) -> &crate::model::Dialog {
          26  +
        &self.dialog
          27  +
    }
          28  +
    #[allow(missing_docs)] // documentation missing in model
          29  +
    pub fn dialog_list(&self) -> &[crate::model::Dialog] {
          30  +
        use std::ops::Deref;
          31  +
        self.dialog_list.deref()
          32  +
    }
          33  +
    #[allow(missing_docs)] // documentation missing in model
          34  +
    pub fn dialog_map(
          35  +
        &self,
          36  +
    ) -> &::std::collections::HashMap<::std::string::String, crate::model::Dialog> {
          37  +
        &self.dialog_map
          38  +
    }
          39  +
}
          40  +
#[allow(clippy::new_without_default)]
          41  +
#[allow(clippy::too_many_arguments)]
          42  +
#[::pyo3::pymethods]
          43  +
impl OperationWithNestedStructureOutput {
          44  +
    #[new]
          45  +
    pub fn new(
          46  +
        dialog: crate::model::Dialog,
          47  +
        dialog_list: ::std::vec::Vec<crate::model::Dialog>,
          48  +
        dialog_map: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
          49  +
    ) -> Self {
          50  +
        Self {
          51  +
            dialog,
          52  +
            dialog_list,
          53  +
            dialog_map,
          54  +
        }
          55  +
    }
          56  +
    fn __repr__(&self) -> String {
          57  +
        format!("{self:?}")
          58  +
    }
          59  +
    fn __str__(&self) -> String {
          60  +
        format!("{self:?}")
          61  +
    }
          62  +
}
          63  +
impl<'source> ::pyo3::FromPyObject<'source>
          64  +
    for std::boxed::Box<OperationWithNestedStructureOutput>
          65  +
{
          66  +
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
          67  +
        ob.extract::<OperationWithNestedStructureOutput>()
          68  +
            .map(Box::new)
          69  +
    }
          70  +
}
          71  +
          72  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<OperationWithNestedStructureOutput> {
          73  +
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
          74  +
        (*self).into_py(py)
          75  +
    }
          76  +
}
          77  +
impl OperationWithNestedStructureOutput {
          78  +
    /// Creates a new builder-style object to manufacture [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
          79  +
    pub fn builder() -> crate::output::operation_with_nested_structure_output::Builder {
          80  +
        crate::output::operation_with_nested_structure_output::Builder::default()
          81  +
    }
          82  +
}
          83  +
          84  +
#[::pyo3::pyclass]
          85  +
/// :param default_string str:
          86  +
/// :param default_boolean bool:
          87  +
/// :param default_list typing.List\[str\]:
          88  +
/// :param default_document_map rest_json.types.Document:
          89  +
/// :param default_document_string rest_json.types.Document:
          90  +
/// :param default_document_boolean rest_json.types.Document:
          91  +
/// :param default_document_list rest_json.types.Document:
          92  +
/// :param default_null_document typing.Optional\[rest_json.types.Document\]:
          93  +
/// :param default_timestamp rest_json.types.DateTime:
          94  +
/// :param default_blob rest_json.types.Blob:
          95  +
/// :param default_byte int:
          96  +
/// :param default_short int:
          97  +
/// :param default_integer int:
          98  +
/// :param default_long int:
          99  +
/// :param default_float float:
         100  +
/// :param default_double float:
         101  +
/// :param default_map typing.Dict\[str, str\]:
         102  +
/// :param default_enum rest_json.model.TestEnum:
         103  +
/// :param default_int_enum int:
         104  +
/// :param empty_string str:
         105  +
/// :param false_boolean bool:
         106  +
/// :param empty_blob rest_json.types.Blob:
         107  +
/// :param zero_byte int:
         108  +
/// :param zero_short int:
         109  +
/// :param zero_integer int:
         110  +
/// :param zero_long int:
         111  +
/// :param zero_float float:
         112  +
/// :param zero_double float:
         113  +
/// :rtype None:
         114  +
#[allow(missing_docs)] // documentation missing in model
         115  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
         116  +
pub struct OperationWithDefaultsOutput {
         117  +
    #[pyo3(get, set)]
         118  +
    /// :type str:
         119  +
    #[allow(missing_docs)] // documentation missing in model
         120  +
    pub default_string: ::std::string::String,
         121  +
    #[pyo3(get, set)]
         122  +
    /// :type bool:
         123  +
    #[allow(missing_docs)] // documentation missing in model
         124  +
    pub default_boolean: bool,
         125  +
    #[pyo3(get, set)]
         126  +
    /// :type typing.List\[str\]:
         127  +
    #[allow(missing_docs)] // documentation missing in model
         128  +
    pub default_list: ::std::vec::Vec<::std::string::String>,
         129  +
    #[pyo3(get, set)]
         130  +
    /// :type rest_json.types.Document:
         131  +
    #[allow(missing_docs)] // documentation missing in model
         132  +
    pub default_document_map: ::aws_smithy_http_server_python::types::Document,
         133  +
    #[pyo3(get, set)]
         134  +
    /// :type rest_json.types.Document:
         135  +
    #[allow(missing_docs)] // documentation missing in model
         136  +
    pub default_document_string: ::aws_smithy_http_server_python::types::Document,
         137  +
    #[pyo3(get, set)]
         138  +
    /// :type rest_json.types.Document:
         139  +
    #[allow(missing_docs)] // documentation missing in model
         140  +
    pub default_document_boolean: ::aws_smithy_http_server_python::types::Document,
         141  +
    #[pyo3(get, set)]
         142  +
    /// :type rest_json.types.Document:
         143  +
    #[allow(missing_docs)] // documentation missing in model
         144  +
    pub default_document_list: ::aws_smithy_http_server_python::types::Document,
         145  +
    #[pyo3(get, set)]
         146  +
    /// :type typing.Optional\[rest_json.types.Document\]:
         147  +
    #[allow(missing_docs)] // documentation missing in model
         148  +
    pub default_null_document:
         149  +
        ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
         150  +
    #[pyo3(get, set)]
         151  +
    /// :type rest_json.types.DateTime:
         152  +
    #[allow(missing_docs)] // documentation missing in model
         153  +
    pub default_timestamp: ::aws_smithy_http_server_python::types::DateTime,
         154  +
    #[pyo3(get, set)]
         155  +
    /// :type rest_json.types.Blob:
         156  +
    #[allow(missing_docs)] // documentation missing in model
         157  +
    pub default_blob: ::aws_smithy_http_server_python::types::Blob,
         158  +
    #[pyo3(get, set)]
         159  +
    /// :type int:
         160  +
    #[allow(missing_docs)] // documentation missing in model
         161  +
    pub default_byte: i8,
         162  +
    #[pyo3(get, set)]
         163  +
    /// :type int:
         164  +
    #[allow(missing_docs)] // documentation missing in model
         165  +
    pub default_short: i16,
         166  +
    #[pyo3(get, set)]
         167  +
    /// :type int:
         168  +
    #[allow(missing_docs)] // documentation missing in model
         169  +
    pub default_integer: i32,
         170  +
    #[pyo3(get, set)]
         171  +
    /// :type int:
         172  +
    #[allow(missing_docs)] // documentation missing in model
         173  +
    pub default_long: i64,
         174  +
    #[pyo3(get, set)]
         175  +
    /// :type float:
         176  +
    #[allow(missing_docs)] // documentation missing in model
         177  +
    pub default_float: f32,
         178  +
    #[pyo3(get, set)]
         179  +
    /// :type float:
         180  +
    #[allow(missing_docs)] // documentation missing in model
         181  +
    pub default_double: f64,
         182  +
    #[pyo3(get, set)]
         183  +
    /// :type typing.Dict\[str, str\]:
         184  +
    #[allow(missing_docs)] // documentation missing in model
         185  +
    pub default_map: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         186  +
    #[pyo3(get, set)]
         187  +
    /// :type rest_json.model.TestEnum:
         188  +
    #[allow(missing_docs)] // documentation missing in model
         189  +
    pub default_enum: crate::model::TestEnum,
         190  +
    #[pyo3(get, set)]
         191  +
    /// :type int:
         192  +
    #[allow(missing_docs)] // documentation missing in model
         193  +
    pub default_int_enum: i32,
         194  +
    #[pyo3(get, set)]
         195  +
    /// :type str:
         196  +
    #[allow(missing_docs)] // documentation missing in model
         197  +
    pub empty_string: ::std::string::String,
         198  +
    #[pyo3(get, set)]
         199  +
    /// :type bool:
         200  +
    #[allow(missing_docs)] // documentation missing in model
         201  +
    pub false_boolean: bool,
         202  +
    #[pyo3(get, set)]
         203  +
    /// :type rest_json.types.Blob:
         204  +
    #[allow(missing_docs)] // documentation missing in model
         205  +
    pub empty_blob: ::aws_smithy_http_server_python::types::Blob,
         206  +
    #[pyo3(get, set)]
         207  +
    /// :type int:
         208  +
    #[allow(missing_docs)] // documentation missing in model
         209  +
    pub zero_byte: i8,
         210  +
    #[pyo3(get, set)]
         211  +
    /// :type int:
         212  +
    #[allow(missing_docs)] // documentation missing in model
         213  +
    pub zero_short: i16,
         214  +
    #[pyo3(get, set)]
         215  +
    /// :type int:
         216  +
    #[allow(missing_docs)] // documentation missing in model
         217  +
    pub zero_integer: i32,
         218  +
    #[pyo3(get, set)]
         219  +
    /// :type int:
         220  +
    #[allow(missing_docs)] // documentation missing in model
         221  +
    pub zero_long: i64,
         222  +
    #[pyo3(get, set)]
         223  +
    /// :type float:
         224  +
    #[allow(missing_docs)] // documentation missing in model
         225  +
    pub zero_float: f32,
         226  +
    #[pyo3(get, set)]
         227  +
    /// :type float:
         228  +
    #[allow(missing_docs)] // documentation missing in model
         229  +
    pub zero_double: f64,
         230  +
}
         231  +
impl OperationWithDefaultsOutput {
         232  +
    #[allow(missing_docs)] // documentation missing in model
         233  +
    pub fn default_string(&self) -> &str {
         234  +
        use std::ops::Deref;
         235  +
        self.default_string.deref()
         236  +
    }
         237  +
    #[allow(missing_docs)] // documentation missing in model
         238  +
    pub fn default_boolean(&self) -> bool {
         239  +
        self.default_boolean
         240  +
    }
         241  +
    #[allow(missing_docs)] // documentation missing in model
         242  +
    pub fn default_list(&self) -> &[::std::string::String] {
         243  +
        use std::ops::Deref;
         244  +
        self.default_list.deref()
         245  +
    }
         246  +
    #[allow(missing_docs)] // documentation missing in model
         247  +
    pub fn default_document_map(&self) -> &::aws_smithy_http_server_python::types::Document {
         248  +
        &self.default_document_map
         249  +
    }
         250  +
    #[allow(missing_docs)] // documentation missing in model
         251  +
    pub fn default_document_string(&self) -> &::aws_smithy_http_server_python::types::Document {
         252  +
        &self.default_document_string
         253  +
    }
         254  +
    #[allow(missing_docs)] // documentation missing in model
         255  +
    pub fn default_document_boolean(&self) -> &::aws_smithy_http_server_python::types::Document {
         256  +
        &self.default_document_boolean
         257  +
    }
         258  +
    #[allow(missing_docs)] // documentation missing in model
         259  +
    pub fn default_document_list(&self) -> &::aws_smithy_http_server_python::types::Document {
         260  +
        &self.default_document_list
         261  +
    }
         262  +
    #[allow(missing_docs)] // documentation missing in model
         263  +
    pub fn default_null_document(
         264  +
        &self,
         265  +
    ) -> ::std::option::Option<&::aws_smithy_http_server_python::types::Document> {
         266  +
        self.default_null_document.as_ref()
         267  +
    }
         268  +
    #[allow(missing_docs)] // documentation missing in model
         269  +
    pub fn default_timestamp(&self) -> &::aws_smithy_http_server_python::types::DateTime {
         270  +
        &self.default_timestamp
         271  +
    }
         272  +
    #[allow(missing_docs)] // documentation missing in model
         273  +
    pub fn default_blob(&self) -> &::aws_smithy_http_server_python::types::Blob {
         274  +
        &self.default_blob
         275  +
    }
         276  +
    #[allow(missing_docs)] // documentation missing in model
         277  +
    pub fn default_byte(&self) -> i8 {
         278  +
        self.default_byte
         279  +
    }
         280  +
    #[allow(missing_docs)] // documentation missing in model
         281  +
    pub fn default_short(&self) -> i16 {
         282  +
        self.default_short
         283  +
    }
         284  +
    #[allow(missing_docs)] // documentation missing in model
         285  +
    pub fn default_integer(&self) -> i32 {
         286  +
        self.default_integer
         287  +
    }
         288  +
    #[allow(missing_docs)] // documentation missing in model
         289  +
    pub fn default_long(&self) -> i64 {
         290  +
        self.default_long
         291  +
    }
         292  +
    #[allow(missing_docs)] // documentation missing in model
         293  +
    pub fn default_float(&self) -> f32 {
         294  +
        self.default_float
         295  +
    }
         296  +
    #[allow(missing_docs)] // documentation missing in model
         297  +
    pub fn default_double(&self) -> f64 {
         298  +
        self.default_double
         299  +
    }
         300  +
    #[allow(missing_docs)] // documentation missing in model
         301  +
    pub fn default_map(
         302  +
        &self,
         303  +
    ) -> &::std::collections::HashMap<::std::string::String, ::std::string::String> {
         304  +
        &self.default_map
         305  +
    }
         306  +
    #[allow(missing_docs)] // documentation missing in model
         307  +
    pub fn default_enum(&self) -> &crate::model::TestEnum {
         308  +
        &self.default_enum
         309  +
    }
         310  +
    #[allow(missing_docs)] // documentation missing in model
         311  +
    pub fn default_int_enum(&self) -> i32 {
         312  +
        self.default_int_enum
         313  +
    }
         314  +
    #[allow(missing_docs)] // documentation missing in model
         315  +
    pub fn empty_string(&self) -> &str {
         316  +
        use std::ops::Deref;
         317  +
        self.empty_string.deref()
         318  +
    }
         319  +
    #[allow(missing_docs)] // documentation missing in model
         320  +
    pub fn false_boolean(&self) -> bool {
         321  +
        self.false_boolean
         322  +
    }
         323  +
    #[allow(missing_docs)] // documentation missing in model
         324  +
    pub fn empty_blob(&self) -> &::aws_smithy_http_server_python::types::Blob {
         325  +
        &self.empty_blob
         326  +
    }
         327  +
    #[allow(missing_docs)] // documentation missing in model
         328  +
    pub fn zero_byte(&self) -> i8 {
         329  +
        self.zero_byte
         330  +
    }
         331  +
    #[allow(missing_docs)] // documentation missing in model
         332  +
    pub fn zero_short(&self) -> i16 {
         333  +
        self.zero_short
         334  +
    }
         335  +
    #[allow(missing_docs)] // documentation missing in model
         336  +
    pub fn zero_integer(&self) -> i32 {
         337  +
        self.zero_integer
         338  +
    }
         339  +
    #[allow(missing_docs)] // documentation missing in model
         340  +
    pub fn zero_long(&self) -> i64 {
         341  +
        self.zero_long
         342  +
    }
         343  +
    #[allow(missing_docs)] // documentation missing in model
         344  +
    pub fn zero_float(&self) -> f32 {
         345  +
        self.zero_float
         346  +
    }
         347  +
    #[allow(missing_docs)] // documentation missing in model
         348  +
    pub fn zero_double(&self) -> f64 {
         349  +
        self.zero_double
         350  +
    }
         351  +
}
         352  +
#[allow(clippy::new_without_default)]
         353  +
#[allow(clippy::too_many_arguments)]
         354  +
#[::pyo3::pymethods]
         355  +
impl OperationWithDefaultsOutput {
         356  +
    #[new]
         357  +
    pub fn new(
         358  +
        default_string: ::std::string::String,
         359  +
        default_boolean: bool,
         360  +
        default_list: ::std::vec::Vec<::std::string::String>,
         361  +
        default_document_map: ::aws_smithy_http_server_python::types::Document,
         362  +
        default_document_string: ::aws_smithy_http_server_python::types::Document,
         363  +
        default_document_boolean: ::aws_smithy_http_server_python::types::Document,
         364  +
        default_document_list: ::aws_smithy_http_server_python::types::Document,
         365  +
        default_null_document: ::std::option::Option<
         366  +
            ::aws_smithy_http_server_python::types::Document,
         367  +
        >,
         368  +
        default_timestamp: ::aws_smithy_http_server_python::types::DateTime,
         369  +
        default_blob: ::aws_smithy_http_server_python::types::Blob,
         370  +
        default_byte: i8,
         371  +
        default_short: i16,
         372  +
        default_integer: i32,
         373  +
        default_long: i64,
         374  +
        default_float: f32,
         375  +
        default_double: f64,
         376  +
        default_map: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         377  +
        default_enum: crate::model::TestEnum,
         378  +
        default_int_enum: i32,
         379  +
        empty_string: ::std::string::String,
         380  +
        false_boolean: bool,
         381  +
        empty_blob: ::aws_smithy_http_server_python::types::Blob,
         382  +
        zero_byte: i8,
         383  +
        zero_short: i16,
         384  +
        zero_integer: i32,
         385  +
        zero_long: i64,
         386  +
        zero_float: f32,
         387  +
        zero_double: f64,
         388  +
    ) -> Self {
         389  +
        Self {
         390  +
            default_string,
         391  +
            default_boolean,
         392  +
            default_list,
         393  +
            default_document_map,
         394  +
            default_document_string,
         395  +
            default_document_boolean,
         396  +
            default_document_list,
         397  +
            default_null_document,
         398  +
            default_timestamp,
         399  +
            default_blob,
         400  +
            default_byte,
         401  +
            default_short,
         402  +
            default_integer,
         403  +
            default_long,
         404  +
            default_float,
         405  +
            default_double,
         406  +
            default_map,
         407  +
            default_enum,
         408  +
            default_int_enum,
         409  +
            empty_string,
         410  +
            false_boolean,
         411  +
            empty_blob,
         412  +
            zero_byte,
         413  +
            zero_short,
         414  +
            zero_integer,
         415  +
            zero_long,
         416  +
            zero_float,
         417  +
            zero_double,
         418  +
        }
         419  +
    }
         420  +
    fn __repr__(&self) -> String {
         421  +
        format!("{self:?}")
         422  +
    }
         423  +
    fn __str__(&self) -> String {
         424  +
        format!("{self:?}")
         425  +
    }
         426  +
}
         427  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<OperationWithDefaultsOutput> {
         428  +
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         429  +
        ob.extract::<OperationWithDefaultsOutput>().map(Box::new)
         430  +
    }
         431  +
}
         432  +
         433  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<OperationWithDefaultsOutput> {
         434  +
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         435  +
        (*self).into_py(py)
         436  +
    }
         437  +
}
         438  +
impl OperationWithDefaultsOutput {
         439  +
    /// Creates a new builder-style object to manufacture [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
         440  +
    pub fn builder() -> crate::output::operation_with_defaults_output::Builder {
         441  +
        crate::output::operation_with_defaults_output::Builder::default()
         442  +
    }
         443  +
}
         444  +
         445  +
#[::pyo3::pyclass]
         446  +
/// :rtype None:
         447  +
#[allow(missing_docs)] // documentation missing in model
         448  +
#[derive(
         449  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         450  +
)]
         451  +
pub struct ContentTypeParametersOutput {}
         452  +
#[allow(clippy::new_without_default)]
         453  +
#[allow(clippy::too_many_arguments)]
         454  +
#[::pyo3::pymethods]
         455  +
impl ContentTypeParametersOutput {
         456  +
    #[new]
         457  +
    pub fn new() -> Self {
         458  +
        Self {}
         459  +
    }
         460  +
    fn __repr__(&self) -> String {
         461  +
        format!("{self:?}")
         462  +
    }
         463  +
    fn __str__(&self) -> String {
         464  +
        format!("{self:?}")
         465  +
    }
         466  +
}
         467  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ContentTypeParametersOutput> {
         468  +
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         469  +
        ob.extract::<ContentTypeParametersOutput>().map(Box::new)
         470  +
    }
         471  +
}
         472  +
         473  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ContentTypeParametersOutput> {
         474  +
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         475  +
        (*self).into_py(py)
         476  +
    }
         477  +
}
         478  +
impl ContentTypeParametersOutput {
         479  +
    /// Creates a new builder-style object to manufacture [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
         480  +
    pub fn builder() -> crate::output::content_type_parameters_output::Builder {
         481  +
        crate::output::content_type_parameters_output::Builder::default()
         482  +
    }
         483  +
}
         484  +
    2    485   
#[::pyo3::pyclass]
    3    486   
/// :rtype None:
    4    487   
#[allow(missing_docs)] // documentation missing in model
    5    488   
#[derive(
    6    489   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
    7    490   
)]
    8    491   
pub struct PutWithContentEncodingOutput {}
    9    492   
#[allow(clippy::new_without_default)]
   10    493   
#[allow(clippy::too_many_arguments)]
   11    494   
#[::pyo3::pymethods]
@@ -124,607 +183,718 @@
  144    627   
        (*self).into_py(py)
  145    628   
    }
  146    629   
}
  147    630   
impl DatetimeOffsetsOutput {
  148    631   
    /// Creates a new builder-style object to manufacture [`DatetimeOffsetsOutput`](crate::output::DatetimeOffsetsOutput).
  149    632   
    pub fn builder() -> crate::output::datetime_offsets_output::Builder {
  150    633   
        crate::output::datetime_offsets_output::Builder::default()
  151    634   
    }
  152    635   
}
  153    636   
         637  +
#[::pyo3::pyclass]
         638  +
/// :param test_id typing.Optional\[str\]:
         639  +
/// :rtype None:
         640  +
#[allow(missing_docs)] // documentation missing in model
         641  +
#[derive(
         642  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         643  +
)]
         644  +
pub struct TestNoInputNoPayloadOutput {
         645  +
    #[pyo3(get, set)]
         646  +
    /// :type typing.Optional\[str\]:
         647  +
    #[allow(missing_docs)] // documentation missing in model
         648  +
    pub test_id: ::std::option::Option<::std::string::String>,
         649  +
}
         650  +
impl TestNoInputNoPayloadOutput {
         651  +
    #[allow(missing_docs)] // documentation missing in model
         652  +
    pub fn test_id(&self) -> ::std::option::Option<&str> {
         653  +
        self.test_id.as_deref()
         654  +
    }
         655  +
}
         656  +
#[allow(clippy::new_without_default)]
         657  +
#[allow(clippy::too_many_arguments)]
         658  +
#[::pyo3::pymethods]
         659  +
impl TestNoInputNoPayloadOutput {
         660  +
    #[new]
         661  +
    pub fn new(test_id: ::std::option::Option<::std::string::String>) -> Self {
         662  +
        Self { test_id }
         663  +
    }
         664  +
    fn __repr__(&self) -> String {
         665  +
        format!("{self:?}")
         666  +
    }
         667  +
    fn __str__(&self) -> String {
         668  +
        format!("{self:?}")
         669  +
    }
         670  +
}
         671  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<TestNoInputNoPayloadOutput> {
         672  +
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         673  +
        ob.extract::<TestNoInputNoPayloadOutput>().map(Box::new)
         674  +
    }
         675  +
}
         676  +
         677  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<TestNoInputNoPayloadOutput> {
         678  +
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         679  +
        (*self).into_py(py)
         680  +
    }
         681  +
}
         682  +
impl TestNoInputNoPayloadOutput {
         683  +
    /// Creates a new builder-style object to manufacture [`TestNoInputNoPayloadOutput`](crate::output::TestNoInputNoPayloadOutput).
         684  +
    pub fn builder() -> crate::output::test_no_input_no_payload_output::Builder {
         685  +
        crate::output::test_no_input_no_payload_output::Builder::default()
         686  +
    }
         687  +
}
         688  +
  154    689   
#[::pyo3::pyclass]
  155    690   
/// :param test_id typing.Optional\[str\]:
  156    691   
/// :rtype None:
  157    692   
#[allow(missing_docs)] // documentation missing in model
  158    693   
#[derive(
  159    694   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  160    695   
)]
  161    696   
pub struct TestNoPayloadOutput {
  162    697   
    #[pyo3(get, set)]
  163    698   
    /// :type typing.Optional\[str\]:
@@ -5502,6037 +5561,6497 @@
 5522   6057   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
 5523   6058   
        (*self).into_py(py)
 5524   6059   
    }
 5525   6060   
}
 5526   6061   
impl NoInputAndNoOutputOutput {
 5527   6062   
    /// Creates a new builder-style object to manufacture [`NoInputAndNoOutputOutput`](crate::output::NoInputAndNoOutputOutput).
 5528   6063   
    pub fn builder() -> crate::output::no_input_and_no_output_output::Builder {
 5529   6064   
        crate::output::no_input_and_no_output_output::Builder::default()
 5530   6065   
    }
 5531   6066   
}
        6067  +
/// See [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
        6068  +
///
        6069  +
pub mod operation_with_nested_structure_output {
        6070  +
        6071  +
    #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
        6072  +
    /// Holds one variant for each of the ways the builder can fail.
        6073  +
        6074  +
    #[allow(clippy::enum_variant_names)]
        6075  +
    pub enum ConstraintViolation {
        6076  +
        /// `dialog` was not provided but it is required when building `OperationWithNestedStructureOutput`.
        6077  +
        MissingDialog,
        6078  +
    }
        6079  +
    impl ::std::fmt::Display for ConstraintViolation {
        6080  +
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        6081  +
            match self {
        6082  +
                ConstraintViolation::MissingDialog => write!(f, "`dialog` was not provided but it is required when building `OperationWithNestedStructureOutput`"),
        6083  +
            }
        6084  +
        }
        6085  +
    }
        6086  +
    impl ::std::error::Error for ConstraintViolation {}
        6087  +
    impl ::std::convert::TryFrom<Builder> for crate::output::OperationWithNestedStructureOutput {
        6088  +
        type Error = ConstraintViolation;
        6089  +
        6090  +
        fn try_from(builder: Builder) -> Result<Self, Self::Error> {
        6091  +
            builder.build()
        6092  +
        }
        6093  +
    }
        6094  +
    /// A builder for [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
        6095  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        6096  +
    pub struct Builder {
        6097  +
        pub(crate) dialog: ::std::option::Option<crate::model::Dialog>,
        6098  +
        pub(crate) dialog_list: ::std::option::Option<::std::vec::Vec<crate::model::Dialog>>,
        6099  +
        pub(crate) dialog_map: ::std::option::Option<
        6100  +
            ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
        6101  +
        >,
        6102  +
    }
        6103  +
    impl Builder {
        6104  +
        #[allow(missing_docs)] // documentation missing in model
        6105  +
        pub fn dialog(mut self, input: crate::model::Dialog) -> Self {
        6106  +
            self.dialog = Some(input);
        6107  +
            self
        6108  +
        }
        6109  +
        #[allow(missing_docs)] // documentation missing in model
        6110  +
        pub fn dialog_list(mut self, input: ::std::vec::Vec<crate::model::Dialog>) -> Self {
        6111  +
            self.dialog_list = Some(input);
        6112  +
            self
        6113  +
        }
        6114  +
        #[allow(missing_docs)] // documentation missing in model
        6115  +
        pub fn dialog_map(
        6116  +
            mut self,
        6117  +
            input: ::std::collections::HashMap<::std::string::String, crate::model::Dialog>,
        6118  +
        ) -> Self {
        6119  +
            self.dialog_map = Some(input);
        6120  +
            self
        6121  +
        }
        6122  +
        /// Consumes the builder and constructs a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput).
        6123  +
        ///
        6124  +
        /// The builder fails to construct a [`OperationWithNestedStructureOutput`](crate::output::OperationWithNestedStructureOutput) if you do not provide a value for all non-`Option`al members.
        6125  +
        ///
        6126  +
        pub fn build(
        6127  +
            self,
        6128  +
        ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
        6129  +
        {
        6130  +
            self.build_enforcing_required_and_enum_traits()
        6131  +
        }
        6132  +
        fn build_enforcing_required_and_enum_traits(
        6133  +
            self,
        6134  +
        ) -> Result<crate::output::OperationWithNestedStructureOutput, ConstraintViolation>
        6135  +
        {
        6136  +
            Ok(crate::output::OperationWithNestedStructureOutput {
        6137  +
                dialog: self.dialog.ok_or(ConstraintViolation::MissingDialog)?,
        6138  +
                dialog_list: self.dialog_list.unwrap_or_else(
        6139  +
                    #[allow(clippy::redundant_closure)]
        6140  +
                    || ::std::vec::Vec::new(),
        6141  +
                ),
        6142  +
                dialog_map: self.dialog_map.unwrap_or_else(
        6143  +
                    #[allow(clippy::redundant_closure)]
        6144  +
                    || ::std::collections::HashMap::new(),
        6145  +
                ),
        6146  +
            })
        6147  +
        }
        6148  +
    }
        6149  +
}
        6150  +
/// See [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
        6151  +
///
        6152  +
pub mod operation_with_defaults_output {
        6153  +
        6154  +
    impl ::std::convert::From<Builder> for crate::output::OperationWithDefaultsOutput {
        6155  +
        fn from(builder: Builder) -> Self {
        6156  +
            builder.build()
        6157  +
        }
        6158  +
    }
        6159  +
    /// A builder for [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
        6160  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        6161  +
    pub struct Builder {
        6162  +
        pub(crate) default_string: ::std::option::Option<::std::string::String>,
        6163  +
        pub(crate) default_boolean: ::std::option::Option<bool>,
        6164  +
        pub(crate) default_list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
        6165  +
        pub(crate) default_document_map:
        6166  +
            ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
        6167  +
        pub(crate) default_document_string:
        6168  +
            ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
        6169  +
        pub(crate) default_document_boolean:
        6170  +
            ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
        6171  +
        pub(crate) default_document_list:
        6172  +
            ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
        6173  +
        pub(crate) default_null_document:
        6174  +
            ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
        6175  +
        pub(crate) default_timestamp:
        6176  +
            ::std::option::Option<::aws_smithy_http_server_python::types::DateTime>,
        6177  +
        pub(crate) default_blob:
        6178  +
            ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,
        6179  +
        pub(crate) default_byte: ::std::option::Option<i8>,
        6180  +
        pub(crate) default_short: ::std::option::Option<i16>,
        6181  +
        pub(crate) default_integer: ::std::option::Option<i32>,
        6182  +
        pub(crate) default_long: ::std::option::Option<i64>,
        6183  +
        pub(crate) default_float: ::std::option::Option<f32>,
        6184  +
        pub(crate) default_double: ::std::option::Option<f64>,
        6185  +
        pub(crate) default_map: ::std::option::Option<
        6186  +
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        6187  +
        >,
        6188  +
        pub(crate) default_enum: ::std::option::Option<crate::model::TestEnum>,
        6189  +
        pub(crate) default_int_enum: ::std::option::Option<i32>,
        6190  +
        pub(crate) empty_string: ::std::option::Option<::std::string::String>,
        6191  +
        pub(crate) false_boolean: ::std::option::Option<bool>,
        6192  +
        pub(crate) empty_blob: ::std::option::Option<::aws_smithy_http_server_python::types::Blob>,
        6193  +
        pub(crate) zero_byte: ::std::option::Option<i8>,
        6194  +
        pub(crate) zero_short: ::std::option::Option<i16>,
        6195  +
        pub(crate) zero_integer: ::std::option::Option<i32>,
        6196  +
        pub(crate) zero_long: ::std::option::Option<i64>,
        6197  +
        pub(crate) zero_float: ::std::option::Option<f32>,
        6198  +
        pub(crate) zero_double: ::std::option::Option<f64>,
        6199  +
    }
        6200  +
    impl Builder {
        6201  +
        #[allow(missing_docs)] // documentation missing in model
        6202  +
        pub fn default_string(mut self, input: ::std::string::String) -> Self {
        6203  +
            self.default_string = Some(input);
        6204  +
            self
        6205  +
        }
        6206  +
        #[allow(missing_docs)] // documentation missing in model
        6207  +
        pub fn default_boolean(mut self, input: bool) -> Self {
        6208  +
            self.default_boolean = Some(input);
        6209  +
            self
        6210  +
        }
        6211  +
        #[allow(missing_docs)] // documentation missing in model
        6212  +
        pub fn default_list(mut self, input: ::std::vec::Vec<::std::string::String>) -> Self {
        6213  +
            self.default_list = Some(input);
        6214  +
            self
        6215  +
        }
        6216  +
        #[allow(missing_docs)] // documentation missing in model
        6217  +
        pub fn default_document_map(
        6218  +
            mut self,
        6219  +
            input: ::aws_smithy_http_server_python::types::Document,
        6220  +
        ) -> Self {
        6221  +
            self.default_document_map = Some(input);
        6222  +
            self
        6223  +
        }
        6224  +
        #[allow(missing_docs)] // documentation missing in model
        6225  +
        pub fn default_document_string(
        6226  +
            mut self,
        6227  +
            input: ::aws_smithy_http_server_python::types::Document,
        6228  +
        ) -> Self {
        6229  +
            self.default_document_string = Some(input);
        6230  +
            self
        6231  +
        }
        6232  +
        #[allow(missing_docs)] // documentation missing in model
        6233  +
        pub fn default_document_boolean(
        6234  +
            mut self,
        6235  +
            input: ::aws_smithy_http_server_python::types::Document,
        6236  +
        ) -> Self {
        6237  +
            self.default_document_boolean = Some(input);
        6238  +
            self
        6239  +
        }
        6240  +
        #[allow(missing_docs)] // documentation missing in model
        6241  +
        pub fn default_document_list(
        6242  +
            mut self,
        6243  +
            input: ::aws_smithy_http_server_python::types::Document,
        6244  +
        ) -> Self {
        6245  +
            self.default_document_list = Some(input);
        6246  +
            self
        6247  +
        }
        6248  +
        #[allow(missing_docs)] // documentation missing in model
        6249  +
        pub fn default_null_document(
        6250  +
            mut self,
        6251  +
            input: ::std::option::Option<::aws_smithy_http_server_python::types::Document>,
        6252  +
        ) -> Self {
        6253  +
            self.default_null_document = input;
        6254  +
            self
        6255  +
        }
        6256  +
        #[allow(missing_docs)] // documentation missing in model
        6257  +
        pub fn default_timestamp(
        6258  +
            mut self,
        6259  +
            input: ::aws_smithy_http_server_python::types::DateTime,
        6260  +
        ) -> Self {
        6261  +
            self.default_timestamp = Some(input);
        6262  +
            self
        6263  +
        }
        6264  +
        #[allow(missing_docs)] // documentation missing in model
        6265  +
        pub fn default_blob(mut self, input: ::aws_smithy_http_server_python::types::Blob) -> Self {
        6266  +
            self.default_blob = Some(input);
        6267  +
            self
        6268  +
        }
        6269  +
        #[allow(missing_docs)] // documentation missing in model
        6270  +
        pub fn default_byte(mut self, input: i8) -> Self {
        6271  +
            self.default_byte = Some(input);
        6272  +
            self
        6273  +
        }
        6274  +
        #[allow(missing_docs)] // documentation missing in model
        6275  +
        pub fn default_short(mut self, input: i16) -> Self {
        6276  +
            self.default_short = Some(input);
        6277  +
            self
        6278  +
        }
        6279  +
        #[allow(missing_docs)] // documentation missing in model
        6280  +
        pub fn default_integer(mut self, input: i32) -> Self {
        6281  +
            self.default_integer = Some(input);
        6282  +
            self
        6283  +
        }
        6284  +
        #[allow(missing_docs)] // documentation missing in model
        6285  +
        pub fn default_long(mut self, input: i64) -> Self {
        6286  +
            self.default_long = Some(input);
        6287  +
            self
        6288  +
        }
        6289  +
        #[allow(missing_docs)] // documentation missing in model
        6290  +
        pub fn default_float(mut self, input: f32) -> Self {
        6291  +
            self.default_float = Some(input);
        6292  +
            self
        6293  +
        }
        6294  +
        #[allow(missing_docs)] // documentation missing in model
        6295  +
        pub fn default_double(mut self, input: f64) -> Self {
        6296  +
            self.default_double = Some(input);
        6297  +
            self
        6298  +
        }
        6299  +
        #[allow(missing_docs)] // documentation missing in model
        6300  +
        pub fn default_map(
        6301  +
            mut self,
        6302  +
            input: ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        6303  +
        ) -> Self {
        6304  +
            self.default_map = Some(input);
        6305  +
            self
        6306  +
        }
        6307  +
        #[allow(missing_docs)] // documentation missing in model
        6308  +
        pub fn default_enum(mut self, input: crate::model::TestEnum) -> Self {
        6309  +
            self.default_enum = Some(input);
        6310  +
            self
        6311  +
        }
        6312  +
        #[allow(missing_docs)] // documentation missing in model
        6313  +
        pub fn default_int_enum(mut self, input: i32) -> Self {
        6314  +
            self.default_int_enum = Some(input);
        6315  +
            self
        6316  +
        }
        6317  +
        #[allow(missing_docs)] // documentation missing in model
        6318  +
        pub fn empty_string(mut self, input: ::std::string::String) -> Self {
        6319  +
            self.empty_string = Some(input);
        6320  +
            self
        6321  +
        }
        6322  +
        #[allow(missing_docs)] // documentation missing in model
        6323  +
        pub fn false_boolean(mut self, input: bool) -> Self {
        6324  +
            self.false_boolean = Some(input);
        6325  +
            self
        6326  +
        }
        6327  +
        #[allow(missing_docs)] // documentation missing in model
        6328  +
        pub fn empty_blob(mut self, input: ::aws_smithy_http_server_python::types::Blob) -> Self {
        6329  +
            self.empty_blob = Some(input);
        6330  +
            self
        6331  +
        }
        6332  +
        #[allow(missing_docs)] // documentation missing in model
        6333  +
        pub fn zero_byte(mut self, input: i8) -> Self {
        6334  +
            self.zero_byte = Some(input);
        6335  +
            self
        6336  +
        }
        6337  +
        #[allow(missing_docs)] // documentation missing in model
        6338  +
        pub fn zero_short(mut self, input: i16) -> Self {
        6339  +
            self.zero_short = Some(input);
        6340  +
            self
        6341  +
        }
        6342  +
        #[allow(missing_docs)] // documentation missing in model
        6343  +
        pub fn zero_integer(mut self, input: i32) -> Self {
        6344  +
            self.zero_integer = Some(input);
        6345  +
            self
        6346  +
        }
        6347  +
        #[allow(missing_docs)] // documentation missing in model
        6348  +
        pub fn zero_long(mut self, input: i64) -> Self {
        6349  +
            self.zero_long = Some(input);
        6350  +
            self
        6351  +
        }
        6352  +
        #[allow(missing_docs)] // documentation missing in model
        6353  +
        pub fn zero_float(mut self, input: f32) -> Self {
        6354  +
            self.zero_float = Some(input);
        6355  +
            self
        6356  +
        }
        6357  +
        #[allow(missing_docs)] // documentation missing in model
        6358  +
        pub fn zero_double(mut self, input: f64) -> Self {
        6359  +
            self.zero_double = Some(input);
        6360  +
            self
        6361  +
        }
        6362  +
        /// Consumes the builder and constructs a [`OperationWithDefaultsOutput`](crate::output::OperationWithDefaultsOutput).
        6363  +
        pub fn build(self) -> crate::output::OperationWithDefaultsOutput {
        6364  +
            self.build_enforcing_required_and_enum_traits()
        6365  +
        }
        6366  +
        fn build_enforcing_required_and_enum_traits(
        6367  +
            self,
        6368  +
        ) -> crate::output::OperationWithDefaultsOutput {
        6369  +
            crate::output::OperationWithDefaultsOutput {
        6370  +
                default_string: self.default_string.unwrap_or_else(
        6371  +
                    #[allow(clippy::redundant_closure)]
        6372  +
                    || String::from("hi"),
        6373  +
                ),
        6374  +
                default_boolean: self.default_boolean.unwrap_or(true),
        6375  +
                default_list: self.default_list.unwrap_or_else(
        6376  +
                    #[allow(clippy::redundant_closure)]
        6377  +
                    || ::std::vec::Vec::new(),
        6378  +
                ),
        6379  +
                default_document_map: self.default_document_map.unwrap_or_else(
        6380  +
                    #[allow(clippy::redundant_closure)]
        6381  +
                    || {
        6382  +
                        ::aws_smithy_types::Document::Object(::std::collections::HashMap::new())
        6383  +
                            .into()
        6384  +
                    },
        6385  +
                ),
        6386  +
                default_document_string: self.default_document_string.unwrap_or_else(
        6387  +
                    #[allow(clippy::redundant_closure)]
        6388  +
                    || {
        6389  +
                        ::aws_smithy_types::Document::String(::std::string::String::from("hi"))
        6390  +
                            .into()
        6391  +
                    },
        6392  +
                ),
        6393  +
                default_document_boolean: self
        6394  +
                    .default_document_boolean
        6395  +
                    .unwrap_or(::aws_smithy_types::Document::Bool(true).into()),
        6396  +
                default_document_list: self.default_document_list.unwrap_or_else(
        6397  +
                    #[allow(clippy::redundant_closure)]
        6398  +
                    || ::aws_smithy_types::Document::Array(::std::vec::Vec::new()).into(),
        6399  +
                ),
        6400  +
                default_null_document: self.default_null_document,
        6401  +
                default_timestamp: self.default_timestamp.unwrap_or_else(
        6402  +
                    #[allow(clippy::redundant_closure)]
        6403  +
                    || ::aws_smithy_types::DateTime::from_fractional_secs(0, 0_f64).into(),
        6404  +
                ),
        6405  +
                default_blob: self.default_blob.unwrap_or_else(
        6406  +
                    #[allow(clippy::redundant_closure)]
        6407  +
                    || ::aws_smithy_types::Blob::new("abc").into(),
        6408  +
                ),
        6409  +
                default_byte: self.default_byte.unwrap_or(1i8),
        6410  +
                default_short: self.default_short.unwrap_or(1i16),
        6411  +
                default_integer: self.default_integer.unwrap_or(10i32),
        6412  +
                default_long: self.default_long.unwrap_or(100i64),
        6413  +
                default_float: self.default_float.unwrap_or(1.0f32),
        6414  +
                default_double: self.default_double.unwrap_or(1.0f64),
        6415  +
                default_map: self.default_map.unwrap_or_else(
        6416  +
                    #[allow(clippy::redundant_closure)]
        6417  +
                    || ::std::collections::HashMap::new(),
        6418  +
                ),
        6419  +
                default_enum: self.default_enum.unwrap_or(
        6420  +
                    "FOO"
        6421  +
                        .parse::<crate::model::TestEnum>()
        6422  +
                        .expect("static value validated to member"),
        6423  +
                ),
        6424  +
                default_int_enum: self.default_int_enum.unwrap_or(1i32),
        6425  +
                empty_string: self.empty_string.unwrap_or_else(
        6426  +
                    #[allow(clippy::redundant_closure)]
        6427  +
                    || String::from(""),
        6428  +
                ),
        6429  +
                false_boolean: self.false_boolean.unwrap_or(false),
        6430  +
                empty_blob: self.empty_blob.unwrap_or_else(
        6431  +
                    #[allow(clippy::redundant_closure)]
        6432  +
                    || ::aws_smithy_types::Blob::new("").into(),
        6433  +
                ),
        6434  +
                zero_byte: self.zero_byte.unwrap_or(0i8),
        6435  +
                zero_short: self.zero_short.unwrap_or(0i16),
        6436  +
                zero_integer: self.zero_integer.unwrap_or(0i32),
        6437  +
                zero_long: self.zero_long.unwrap_or(0i64),
        6438  +
                zero_float: self.zero_float.unwrap_or(0.0f32),
        6439  +
                zero_double: self.zero_double.unwrap_or(0.0f64),
        6440  +
            }
        6441  +
        }
        6442  +
    }
        6443  +
}
        6444  +
/// See [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
        6445  +
///
        6446  +
pub mod content_type_parameters_output {
        6447  +
        6448  +
    impl ::std::convert::From<Builder> for crate::output::ContentTypeParametersOutput {
        6449  +
        fn from(builder: Builder) -> Self {
        6450  +
            builder.build()
        6451  +
        }
        6452  +
    }
        6453  +
    /// A builder for [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
        6454  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        6455  +
    pub struct Builder {}
        6456  +
    impl Builder {
        6457  +
        /// Consumes the builder and constructs a [`ContentTypeParametersOutput`](crate::output::ContentTypeParametersOutput).
        6458  +
        pub fn build(self) -> crate::output::ContentTypeParametersOutput {
        6459  +
            self.build_enforcing_required_and_enum_traits()
        6460  +
        }
        6461  +
        fn build_enforcing_required_and_enum_traits(
        6462  +
            self,
        6463  +
        ) -> crate::output::ContentTypeParametersOutput {
        6464  +
            crate::output::ContentTypeParametersOutput {}
        6465  +
        }
        6466  +
    }
        6467  +
}
 5532   6468   
/// See [`PutWithContentEncodingOutput`](crate::output::PutWithContentEncodingOutput).
 5533   6469   
///
 5534   6470   
pub mod put_with_content_encoding_output {
 5535   6471   
 5536   6472   
    impl ::std::convert::From<Builder> for crate::output::PutWithContentEncodingOutput {
 5537   6473   
        fn from(builder: Builder) -> Self {
 5538   6474   
            builder.build()
 5539   6475   
        }
 5540   6476   
    }
 5541   6477   
    /// A builder for [`PutWithContentEncodingOutput`](crate::output::PutWithContentEncodingOutput).
@@ -5598,6534 +5657,6626 @@
 5618   6554   
        pub fn build(self) -> crate::output::DatetimeOffsetsOutput {
 5619   6555   
            self.build_enforcing_required_and_enum_traits()
 5620   6556   
        }
 5621   6557   
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::DatetimeOffsetsOutput {
 5622   6558   
            crate::output::DatetimeOffsetsOutput {
 5623   6559   
                datetime: self.datetime,
 5624   6560   
            }
 5625   6561   
        }
 5626   6562   
    }
 5627   6563   
}
        6564  +
/// See [`TestNoInputNoPayloadOutput`](crate::output::TestNoInputNoPayloadOutput).
        6565  +
///
        6566  +
pub mod test_no_input_no_payload_output {
        6567  +
        6568  +
    impl ::std::convert::From<Builder> for crate::output::TestNoInputNoPayloadOutput {
        6569  +
        fn from(builder: Builder) -> Self {
        6570  +
            builder.build()
        6571  +
        }
        6572  +
    }
        6573  +
    /// A builder for [`TestNoInputNoPayloadOutput`](crate::output::TestNoInputNoPayloadOutput).
        6574  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
        6575  +
    pub struct Builder {
        6576  +
        pub(crate) test_id: ::std::option::Option<::std::string::String>,
        6577  +
    }
        6578  +
    impl Builder {
        6579  +
        #[allow(missing_docs)] // documentation missing in model
        6580  +
        pub fn test_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
        6581  +
            self.test_id = input;
        6582  +
            self
        6583  +
        }
        6584  +
        /// Consumes the builder and constructs a [`TestNoInputNoPayloadOutput`](crate::output::TestNoInputNoPayloadOutput).
        6585  +
        pub fn build(self) -> crate::output::TestNoInputNoPayloadOutput {
        6586  +
            self.build_enforcing_required_and_enum_traits()
        6587  +
        }
        6588  +
        fn build_enforcing_required_and_enum_traits(
        6589  +
            self,
        6590  +
        ) -> crate::output::TestNoInputNoPayloadOutput {
        6591  +
            crate::output::TestNoInputNoPayloadOutput {
        6592  +
                test_id: self.test_id,
        6593  +
            }
        6594  +
        }
        6595  +
    }
        6596  +
}
 5628   6597   
/// See [`TestNoPayloadOutput`](crate::output::TestNoPayloadOutput).
 5629   6598   
///
 5630   6599   
pub mod test_no_payload_output {
 5631   6600   
 5632   6601   
    impl ::std::convert::From<Builder> for crate::output::TestNoPayloadOutput {
 5633   6602   
        fn from(builder: Builder) -> Self {
 5634   6603   
            builder.build()
 5635   6604   
        }
 5636   6605   
    }
 5637   6606   
    /// A builder for [`TestNoPayloadOutput`](crate::output::TestNoPayloadOutput).