Server Test

rev. 960037ddd6baa855c43528258ed60c279b45ae58 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/.cargo/config.toml

@@ -1,1 +0,2 @@

 [build]
 rustflags = ["--cfg", "aws_sdk_unstable"]
  No newline at end of file
 rustflags = ["--deny", "warnings", "--cfg", "aws_sdk_unstable"]

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

@@ -28,28 +88,87 @@

↥ Expand context

-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EventStreamsOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-44
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EventStreamsOperationInputFuture;
-47

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EVENTSTREAMSOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-55
+            }
             crate::protocol_serde::shape_event_streams_operation::de_event_streams_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-65
+                )
             },
         );

↧ Expand context

         EventStreamsOperationInputFuture {
             inner: Box::pin(fut),
-70
+        }
-71
+    }
-72
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EventStreamsOperationOutput
-77
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_event_streams_operation::ser_event_streams_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-84
+                        }
-85
+                    }
-86
+    }
-87
+}

@@ -129,128 +189,187 @@

↥ Expand context

-128
+    }
-129
+}
-130
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingBlobOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-139
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-144
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingBlobOperationInputFuture;
-147

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGBLOBOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-155
+            }
             crate::protocol_serde::shape_streaming_blob_operation::de_streaming_blob_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-165
+                )
             },
         );

↧ Expand context

         StreamingBlobOperationInputFuture {
             inner: Box::pin(fut),
-170
+        }
-171
+    }
-172
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingBlobOperationOutput
-177
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_blob_operation::ser_streaming_blob_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-184
+                        }
-185
+                    }
-186
+    }
-187
+}

@@ -204,202 +264,261 @@

↥ Expand context

-202
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-209
+    }
-210
+}
-211
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NonStreamingBlobOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-220
     B::Data: Send,

     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-224
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NonStreamingBlobOperationInputFuture;
-227
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_non_streaming_blob_operation::de_non_streaming_blob_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-239
+                )
             },
         );

↧ Expand context

         NonStreamingBlobOperationInputFuture {
             inner: Box::pin(fut),
-244
+        }
-245
+    }
-246
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NonStreamingBlobOperationOutput
-251
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_non_streaming_blob_operation::ser_non_streaming_blob_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-258
+                        }
-259
+                    }
-260
+    }
-261
+}

@@ -287,284 +347,343 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-285
+    }
-286
+}
-287
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfEnumStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-296
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-300
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfEnumStringOperationInputFuture;
-303

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFENUMSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-311
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_enum_string_operation::de_query_params_targeting_map_of_enum_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-321
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfEnumStringOperationInputFuture {
             inner: Box::pin(fut),
-326
+        }
-327
+    }
-328
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfEnumStringOperationOutput
-333
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_enum_string_operation::ser_query_params_targeting_map_of_enum_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-340
+                        }
-341
+                    }
-342
+    }
-343
+}

@@ -388,384 +448,443 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-385
+    }
-386
+}
-387
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-396
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-400
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersTargetingLengthMapOperationInputFuture;
-403

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPREFIXHEADERSTARGETINGLENGTHMAPOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-411
+            }
             crate::protocol_serde::shape_http_prefix_headers_targeting_length_map_operation::de_http_prefix_headers_targeting_length_map_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-421
+                )
             },
         );

↧ Expand context

         HttpPrefixHeadersTargetingLengthMapOperationInputFuture {
             inner: Box::pin(fut),
-426
+        }
-427
+    }
-428
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersTargetingLengthMapOperationOutput
-433
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers_targeting_length_map_operation::ser_http_prefix_headers_targeting_length_map_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-440
+                        }
-441
+                    }
-442
+    }
-443
+}

@@ -491,486 +551,545 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-487
+    }
-488
+}
-489
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfLengthPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-498
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-502
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfLengthPatternStringOperationInputFuture;
-505

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFLENGTHPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-513
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_pattern_string_operation::de_query_params_targeting_map_of_list_of_length_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-523
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfLengthPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-528
+        }
-529
+    }
-530
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfLengthPatternStringOperationOutput
-535
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_pattern_string_operation::ser_query_params_targeting_map_of_list_of_length_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-542
+                        }
-543
+                    }
-544
+    }
-545
+}

@@ -592,586 +652,645 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-587
+    }
-588
+}
-589
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfLengthPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-598
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-602
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfLengthPatternStringOperationInputFuture;
-605

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLENGTHPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-613
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_length_pattern_string_operation::de_query_params_targeting_map_of_length_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-623
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfLengthPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-628
+        }
-629
+    }
-630
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfLengthPatternStringOperationOutput
-635
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_length_pattern_string_operation::ser_query_params_targeting_map_of_length_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-642
+                        }
-643
+                    }
-644
+    }
-645
+}

@@ -693,686 +753,745 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-687
+    }
-688
+}
-689
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-698
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-702
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfPatternStringOperationInputFuture;
-705

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-713
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_pattern_string_operation::de_query_params_targeting_map_of_list_of_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-723
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-728
+        }
-729
+    }
-730
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfPatternStringOperationOutput
-735
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_pattern_string_operation::ser_query_params_targeting_map_of_list_of_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-742
+                        }
-743
+                    }
-744
+    }
-745
+}

@@ -794,786 +854,845 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-787
+    }
-788
+}
-789
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-798
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-802
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfPatternStringOperationInputFuture;
-805

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-813
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_pattern_string_operation::de_query_params_targeting_map_of_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-823
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-828
+        }
-829
+    }
-830
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfPatternStringOperationOutput
-835
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_pattern_string_operation::ser_query_params_targeting_map_of_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-842
+                        }
-843
+                    }
-844
+    }
-845
+}

@@ -895,886 +955,945 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-887
+    }
-888
+}
-889
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfEnumStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-898
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-902
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfEnumStringOperationInputFuture;
-905

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFENUMSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-913
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_enum_string_operation::de_query_params_targeting_map_of_list_of_enum_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-923
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfEnumStringOperationInputFuture {
             inner: Box::pin(fut),
-928
+        }
-929
+    }
-930
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfEnumStringOperationOutput
-935
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_enum_string_operation::ser_query_params_targeting_map_of_list_of_enum_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-942
+                        }
-943
+                    }
-944
+    }
-945
+}

@@ -998,988 +1058,1047 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-989
+    }
-990
+}
-991
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfLengthListOfPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1000
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1004
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputFuture;
-1007

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLENGTHLISTOFPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1015
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_length_list_of_pattern_string_operation::de_query_params_targeting_map_of_length_list_of_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1025
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-1030
+        }
-1031
+    }
-1032
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfLengthListOfPatternStringOperationOutput
-1037
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_length_list_of_pattern_string_operation::ser_query_params_targeting_map_of_length_list_of_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1044
+                        }
-1045
+                    }
-1046
+    }
-1047
+}

@@ -1099,1088 +1159,1147 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1089
+    }
-1090
+}
-1091
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfSetOfLengthStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1100
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1104
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfSetOfLengthStringOperationInputFuture;
-1107

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFSETOFLENGTHSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1115
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_set_of_length_string_operation::de_query_params_targeting_map_of_set_of_length_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1125
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfSetOfLengthStringOperationInputFuture {
             inner: Box::pin(fut),
-1130
+        }
-1131
+    }
-1132
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfSetOfLengthStringOperationOutput
-1137
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_set_of_length_string_operation::ser_query_params_targeting_map_of_set_of_length_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1144
+                        }
-1145
+                    }
-1146
+    }
-1147
+}

@@ -1200,1188 +1260,1247 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1189
+    }
-1190
+}
-1191
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfLengthStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1200
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1204
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfLengthStringOperationInputFuture;
-1207

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFLENGTHSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1215
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_string_operation::de_query_params_targeting_map_of_list_of_length_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1225
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfLengthStringOperationInputFuture {
             inner: Box::pin(fut),
-1230
+        }
-1231
+    }
-1232
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfLengthStringOperationOutput
-1237
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_string_operation::ser_query_params_targeting_map_of_list_of_length_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1244
+                        }
-1245
+                    }
-1246
+    }
-1247
+}

@@ -1301,1288 +1361,1347 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1289
+    }
-1290
+}
-1291
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfLengthStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1300
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1304
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfLengthStringOperationInputFuture;
-1307

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLENGTHSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1315
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_length_string_operation::de_query_params_targeting_map_of_length_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1325
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfLengthStringOperationInputFuture {
             inner: Box::pin(fut),
-1330
+        }
-1331
+    }
-1332
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfLengthStringOperationOutput
-1337
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_length_string_operation::ser_query_params_targeting_map_of_length_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1344
+                        }
-1345
+                    }
-1346
+    }
-1347
+}

@@ -1401,1387 +1461,1446 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1388
+    }
-1389
+}
-1390
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingLengthMapOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1399
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1403
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingLengthMapOperationInputFuture;
-1406

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGLENGTHMAPOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1414
+            }
             crate::protocol_serde::shape_query_params_targeting_length_map_operation::de_query_params_targeting_length_map_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1424
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingLengthMapOperationInputFuture {
             inner: Box::pin(fut),
-1429
+        }
-1430
+    }
-1431
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingLengthMapOperationOutput
-1436
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_length_map_operation::ser_query_params_targeting_length_map_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1443
+                        }
-1444
+                    }
-1445
+    }
-1446
+}

@@ -1501,1486 +1561,1545 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1487
+    }
-1488
+}
-1489
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedRecursiveShapesOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1498
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1502
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedRecursiveShapesOperationInputFuture;
-1505

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDRECURSIVESHAPESOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1513
+            }
             crate::protocol_serde::shape_constrained_recursive_shapes_operation::de_constrained_recursive_shapes_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1523
+                )
             },
         );

↧ Expand context

         ConstrainedRecursiveShapesOperationInputFuture {
             inner: Box::pin(fut),
-1528
+        }
-1529
+    }
-1530
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedRecursiveShapesOperationOutput
-1535
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_recursive_shapes_operation::ser_constrained_recursive_shapes_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1542
+                        }
-1543
+                    }
-1544
+    }
-1545
+}

@@ -1602,1586 +1662,1645 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1587
+    }
-1588
+}
-1589
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedHttpPayloadBoundShapeOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1598
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1602
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedHttpPayloadBoundShapeOperationInputFuture;
-1605

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDHTTPPAYLOADBOUNDSHAPEOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1613
+            }
             crate::protocol_serde::shape_constrained_http_payload_bound_shape_operation::de_constrained_http_payload_bound_shape_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1623
+                )
             },
         );

↧ Expand context

         ConstrainedHttpPayloadBoundShapeOperationInputFuture {
             inner: Box::pin(fut),
-1628
+        }
-1629
+    }
-1630
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedHttpPayloadBoundShapeOperationOutput
-1635
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_http_payload_bound_shape_operation::ser_constrained_http_payload_bound_shape_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1642
+                        }
-1643
+                    }
-1644
+    }
-1645
+}

@@ -1702,1685 +1762,1744 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1686
+    }
-1687
+}
-1688
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedHttpBoundShapesOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1697
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1701
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedHttpBoundShapesOperationInputFuture;
-1704

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDHTTPBOUNDSHAPESOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1712
+            }
             crate::protocol_serde::shape_constrained_http_bound_shapes_operation::de_constrained_http_bound_shapes_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1722
+                )
             },
         );

↧ Expand context

         ConstrainedHttpBoundShapesOperationInputFuture {
             inner: Box::pin(fut),
-1727
+        }
-1728
+    }
-1729
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedHttpBoundShapesOperationOutput
-1734
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_http_bound_shapes_operation::ser_constrained_http_bound_shapes_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1741
+                        }
-1742
+                    }
-1743
+    }
-1744
+}

@@ -1802,1784 +1862,1843 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1785
+    }
-1786
+}
-1787
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedShapesOnlyInOutputOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1796
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1800
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedShapesOnlyInOutputOperationInputFuture;
-1803

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDSHAPESONLYINOUTPUTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1811
+            }
             crate::protocol_serde::shape_constrained_shapes_only_in_output_operation::de_constrained_shapes_only_in_output_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1821
+                )
             },
         );

↧ Expand context

         ConstrainedShapesOnlyInOutputOperationInputFuture {
             inner: Box::pin(fut),
-1826
+        }
-1827
+    }
-1828
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedShapesOnlyInOutputOperationOutput
-1833
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_shapes_only_in_output_operation::ser_constrained_shapes_only_in_output_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1840
+                        }
-1841
+                    }
-1842
+    }
-1843
+}

@@ -1884,1865 +1944,1924 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1866
+    }
-1867
+}
-1868
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedShapesOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1877
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1881
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedShapesOperationInputFuture;
-1884

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDSHAPESOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1892
+            }
             crate::protocol_serde::shape_constrained_shapes_operation::de_constrained_shapes_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1902
+                )
             },
         );

↧ Expand context

         ConstrainedShapesOperationInputFuture {
             inner: Box::pin(fut),
-1907
+        }
-1908
+    }
-1909
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedShapesOperationOutput
-1914
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_shapes_operation::ser_constrained_shapes_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1921
+                        }
-1922
+                    }
-1923
+    }
-1924
+}

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

@@ -28,28 +88,87 @@

↥ Expand context

-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EventStreamsOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-44
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EventStreamsOperationInputFuture;
-47

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EVENTSTREAMSOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-55
+            }
             crate::protocol_serde::shape_event_streams_operation::de_event_streams_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-65
+                )
             },
         );

↧ Expand context

         EventStreamsOperationInputFuture {
             inner: Box::pin(fut),
-70
+        }
-71
+    }
-72
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EventStreamsOperationOutput
-77
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_event_streams_operation::ser_event_streams_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-84
+                        }
-85
+                    }
-86
+    }
-87
+}

@@ -129,128 +189,187 @@

↥ Expand context

-128
+    }
-129
+}
-130
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingBlobOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-139
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-144
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingBlobOperationInputFuture;
-147

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGBLOBOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-155
+            }
             crate::protocol_serde::shape_streaming_blob_operation::de_streaming_blob_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-165
+                )
             },
         );

↧ Expand context

         StreamingBlobOperationInputFuture {
             inner: Box::pin(fut),
-170
+        }
-171
+    }
-172
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingBlobOperationOutput
-177
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_blob_operation::ser_streaming_blob_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-184
+                        }
-185
+                    }
-186
+    }
-187
+}

@@ -204,202 +264,261 @@

↥ Expand context

-202
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-209
+    }
-210
+}
-211
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NonStreamingBlobOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-220
     B::Data: Send,

     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-224
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NonStreamingBlobOperationInputFuture;
-227
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_non_streaming_blob_operation::de_non_streaming_blob_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-239
+                )
             },
         );

↧ Expand context

         NonStreamingBlobOperationInputFuture {
             inner: Box::pin(fut),
-244
+        }
-245
+    }
-246
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NonStreamingBlobOperationOutput
-251
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_non_streaming_blob_operation::ser_non_streaming_blob_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-258
+                        }
-259
+                    }
-260
+    }
-261
+}

@@ -287,284 +347,343 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-285
+    }
-286
+}
-287
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfEnumStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-296
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-300
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfEnumStringOperationInputFuture;
-303

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFENUMSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-311
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_enum_string_operation::de_query_params_targeting_map_of_enum_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-321
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfEnumStringOperationInputFuture {
             inner: Box::pin(fut),
-326
+        }
-327
+    }
-328
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfEnumStringOperationOutput
-333
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_enum_string_operation::ser_query_params_targeting_map_of_enum_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-340
+                        }
-341
+                    }
-342
+    }
-343
+}

@@ -388,384 +448,443 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-385
+    }
-386
+}
-387
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersTargetingLengthMapOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-396
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-400
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersTargetingLengthMapOperationInputFuture;
-403

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPREFIXHEADERSTARGETINGLENGTHMAPOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-411
+            }
             crate::protocol_serde::shape_http_prefix_headers_targeting_length_map_operation::de_http_prefix_headers_targeting_length_map_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-421
+                )
             },
         );

↧ Expand context

         HttpPrefixHeadersTargetingLengthMapOperationInputFuture {
             inner: Box::pin(fut),
-426
+        }
-427
+    }
-428
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersTargetingLengthMapOperationOutput
-433
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers_targeting_length_map_operation::ser_http_prefix_headers_targeting_length_map_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-440
+                        }
-441
+                    }
-442
+    }
-443
+}

@@ -491,486 +551,545 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-487
+    }
-488
+}
-489
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfLengthPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-498
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-502
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfLengthPatternStringOperationInputFuture;
-505

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFLENGTHPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-513
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_pattern_string_operation::de_query_params_targeting_map_of_list_of_length_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-523
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfLengthPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-528
+        }
-529
+    }
-530
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfLengthPatternStringOperationOutput
-535
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_pattern_string_operation::ser_query_params_targeting_map_of_list_of_length_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-542
+                        }
-543
+                    }
-544
+    }
-545
+}

@@ -592,586 +652,645 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-587
+    }
-588
+}
-589
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfLengthPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-598
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-602
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfLengthPatternStringOperationInputFuture;
-605

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLENGTHPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-613
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_length_pattern_string_operation::de_query_params_targeting_map_of_length_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-623
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfLengthPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-628
+        }
-629
+    }
-630
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfLengthPatternStringOperationOutput
-635
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_length_pattern_string_operation::ser_query_params_targeting_map_of_length_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-642
+                        }
-643
+                    }
-644
+    }
-645
+}

@@ -693,686 +753,745 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-687
+    }
-688
+}
-689
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-698
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-702
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfPatternStringOperationInputFuture;
-705

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-713
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_pattern_string_operation::de_query_params_targeting_map_of_list_of_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-723
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-728
+        }
-729
+    }
-730
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfPatternStringOperationOutput
-735
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_pattern_string_operation::ser_query_params_targeting_map_of_list_of_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-742
+                        }
-743
+                    }
-744
+    }
-745
+}

@@ -794,786 +854,845 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-787
+    }
-788
+}
-789
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-798
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-802
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfPatternStringOperationInputFuture;
-805

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-813
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_pattern_string_operation::de_query_params_targeting_map_of_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-823
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-828
+        }
-829
+    }
-830
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfPatternStringOperationOutput
-835
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_pattern_string_operation::ser_query_params_targeting_map_of_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-842
+                        }
-843
+                    }
-844
+    }
-845
+}

@@ -895,886 +955,945 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-887
+    }
-888
+}
-889
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfEnumStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-898
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-902
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfEnumStringOperationInputFuture;
-905

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFENUMSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-913
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_enum_string_operation::de_query_params_targeting_map_of_list_of_enum_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-923
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfEnumStringOperationInputFuture {
             inner: Box::pin(fut),
-928
+        }
-929
+    }
-930
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfEnumStringOperationOutput
-935
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_enum_string_operation::ser_query_params_targeting_map_of_list_of_enum_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-942
+                        }
-943
+                    }
-944
+    }
-945
+}

@@ -998,988 +1058,1047 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-989
+    }
-990
+}
-991
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfLengthListOfPatternStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1000
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1004
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputFuture;
-1007

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLENGTHLISTOFPATTERNSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1015
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_length_list_of_pattern_string_operation::de_query_params_targeting_map_of_length_list_of_pattern_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1025
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfLengthListOfPatternStringOperationInputFuture {
             inner: Box::pin(fut),
-1030
+        }
-1031
+    }
-1032
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfLengthListOfPatternStringOperationOutput
-1037
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_length_list_of_pattern_string_operation::ser_query_params_targeting_map_of_length_list_of_pattern_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1044
+                        }
-1045
+                    }
-1046
+    }
-1047
+}

@@ -1099,1088 +1159,1147 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1089
+    }
-1090
+}
-1091
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfSetOfLengthStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1100
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1104
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfSetOfLengthStringOperationInputFuture;
-1107

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFSETOFLENGTHSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1115
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_set_of_length_string_operation::de_query_params_targeting_map_of_set_of_length_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1125
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfSetOfLengthStringOperationInputFuture {
             inner: Box::pin(fut),
-1130
+        }
-1131
+    }
-1132
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfSetOfLengthStringOperationOutput
-1137
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_set_of_length_string_operation::ser_query_params_targeting_map_of_set_of_length_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1144
+                        }
-1145
+                    }
-1146
+    }
-1147
+}

@@ -1200,1188 +1260,1247 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1189
+    }
-1190
+}
-1191
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfListOfLengthStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1200
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1204
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfListOfLengthStringOperationInputFuture;
-1207

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLISTOFLENGTHSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1215
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_string_operation::de_query_params_targeting_map_of_list_of_length_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1225
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfListOfLengthStringOperationInputFuture {
             inner: Box::pin(fut),
-1230
+        }
-1231
+    }
-1232
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfListOfLengthStringOperationOutput
-1237
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_list_of_length_string_operation::ser_query_params_targeting_map_of_list_of_length_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1244
+                        }
-1245
+                    }
-1246
+    }
-1247
+}

@@ -1301,1288 +1361,1347 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1289
+    }
-1290
+}
-1291
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingMapOfLengthStringOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1300
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1304
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingMapOfLengthStringOperationInputFuture;
-1307

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGMAPOFLENGTHSTRINGOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1315
+            }
             crate::protocol_serde::shape_query_params_targeting_map_of_length_string_operation::de_query_params_targeting_map_of_length_string_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1325
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingMapOfLengthStringOperationInputFuture {
             inner: Box::pin(fut),
-1330
+        }
-1331
+    }
-1332
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingMapOfLengthStringOperationOutput
-1337
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_map_of_length_string_operation::ser_query_params_targeting_map_of_length_string_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1344
+                        }
-1345
+                    }
-1346
+    }
-1347
+}

@@ -1401,1387 +1461,1446 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1388
+    }
-1389
+}
-1390
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsTargetingLengthMapOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1399
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1403
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsTargetingLengthMapOperationInputFuture;
-1406

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSTARGETINGLENGTHMAPOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1414
+            }
             crate::protocol_serde::shape_query_params_targeting_length_map_operation::de_query_params_targeting_length_map_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1424
+                )
             },
         );

↧ Expand context

         QueryParamsTargetingLengthMapOperationInputFuture {
             inner: Box::pin(fut),
-1429
+        }
-1430
+    }
-1431
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsTargetingLengthMapOperationOutput
-1436
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_targeting_length_map_operation::ser_query_params_targeting_length_map_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1443
+                        }
-1444
+                    }
-1445
+    }
-1446
+}

@@ -1501,1486 +1561,1545 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1487
+    }
-1488
+}
-1489
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedRecursiveShapesOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1498
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1502
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedRecursiveShapesOperationInputFuture;
-1505

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDRECURSIVESHAPESOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1513
+            }
             crate::protocol_serde::shape_constrained_recursive_shapes_operation::de_constrained_recursive_shapes_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1523
+                )
             },
         );

↧ Expand context

         ConstrainedRecursiveShapesOperationInputFuture {
             inner: Box::pin(fut),
-1528
+        }
-1529
+    }
-1530
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedRecursiveShapesOperationOutput
-1535
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_recursive_shapes_operation::ser_constrained_recursive_shapes_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1542
+                        }
-1543
+                    }
-1544
+    }
-1545
+}

@@ -1602,1586 +1662,1645 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1587
+    }
-1588
+}
-1589
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedHttpPayloadBoundShapeOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1598
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1602
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedHttpPayloadBoundShapeOperationInputFuture;
-1605

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDHTTPPAYLOADBOUNDSHAPEOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1613
+            }
             crate::protocol_serde::shape_constrained_http_payload_bound_shape_operation::de_constrained_http_payload_bound_shape_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1623
+                )
             },
         );

↧ Expand context

         ConstrainedHttpPayloadBoundShapeOperationInputFuture {
             inner: Box::pin(fut),
-1628
+        }
-1629
+    }
-1630
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedHttpPayloadBoundShapeOperationOutput
-1635
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_http_payload_bound_shape_operation::ser_constrained_http_payload_bound_shape_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1642
+                        }
-1643
+                    }
-1644
+    }
-1645
+}

@@ -1702,1685 +1762,1744 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1686
+    }
-1687
+}
-1688
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedHttpBoundShapesOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1697
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1701
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedHttpBoundShapesOperationInputFuture;
-1704

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDHTTPBOUNDSHAPESOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1712
+            }
             crate::protocol_serde::shape_constrained_http_bound_shapes_operation::de_constrained_http_bound_shapes_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1722
+                )
             },
         );

↧ Expand context

         ConstrainedHttpBoundShapesOperationInputFuture {
             inner: Box::pin(fut),
-1727
+        }
-1728
+    }
-1729
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedHttpBoundShapesOperationOutput
-1734
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_http_bound_shapes_operation::ser_constrained_http_bound_shapes_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1741
+                        }
-1742
+                    }
-1743
+    }
-1744
+}

@@ -1802,1784 +1862,1843 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1785
+    }
-1786
+}
-1787
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedShapesOnlyInOutputOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1796
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1800
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedShapesOnlyInOutputOperationInputFuture;
-1803

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDSHAPESONLYINOUTPUTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1811
+            }
             crate::protocol_serde::shape_constrained_shapes_only_in_output_operation::de_constrained_shapes_only_in_output_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1821
+                )
             },
         );

↧ Expand context

         ConstrainedShapesOnlyInOutputOperationInputFuture {
             inner: Box::pin(fut),
-1826
+        }
-1827
+    }
-1828
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedShapesOnlyInOutputOperationOutput
-1833
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_shapes_only_in_output_operation::ser_constrained_shapes_only_in_output_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1840
+                        }
-1841
+                    }
-1842
+    }
-1843
+}

@@ -1884,1865 +1944,1924 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1866
+    }
-1867
+}
-1868
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstrainedShapesOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1877
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1881
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstrainedShapesOperationInputFuture;
-1884

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTRAINEDSHAPESOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1892
+            }
             crate::protocol_serde::shape_constrained_shapes_operation::de_constrained_shapes_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1902
+                )
             },
         );

↧ Expand context

         ConstrainedShapesOperationInputFuture {
             inner: Box::pin(fut),
-1907
+        }
-1908
+    }
-1909
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstrainedShapesOperationOutput
-1914
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constrained_shapes_operation::ser_constrained_shapes_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1921
+                        }
-1922
+                    }
-1923
+    }
-1924
+}

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

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StartSnapshotInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StartSnapshotInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STARTSNAPSHOT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_start_snapshot::de_start_snapshot_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         StartSnapshotInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StartSnapshotOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_start_snapshot::ser_start_snapshot_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-78
+            }
-79
+        }
-80
+    }
-81
+}

@@ -127,126 +187,185 @@

↥ Expand context

-126
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PutSnapshotBlockInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-135
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-140
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PutSnapshotBlockInputFuture;
-143
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTSNAPSHOTBLOCK,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-151
+            }
             crate::protocol_serde::shape_put_snapshot_block::de_put_snapshot_block_http_request(
                 request,
-154
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-163
+                )
             },
         );

↧ Expand context

         PutSnapshotBlockInputFuture {
             inner: Box::pin(fut),
-168
+        }
-169
+    }
-170
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PutSnapshotBlockOutput
-175
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_snapshot_block::ser_put_snapshot_block_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-184
+            }
-185
+        }

@@ -235,233 +295,292 @@

↥ Expand context

-233
+}
-234
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ListSnapshotBlocksInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-243
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-247
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ListSnapshotBlocksInputFuture;
-250
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_LISTSNAPSHOTBLOCKS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-258
+            }
             crate::protocol_serde::shape_list_snapshot_blocks::de_list_snapshot_blocks_http_request(
                 request,
-261
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-270
+                )
             },
         );

↧ Expand context

         ListSnapshotBlocksInputFuture {
             inner: Box::pin(fut),
-275
+        }
-276
+    }
-277
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ListSnapshotBlocksOutput
-282
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_list_snapshot_blocks::ser_list_snapshot_blocks_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-289
+                        }
-290
+                    }
-291
+    }
-292
+}

@@ -341,338 +401,397 @@

↥ Expand context

-338
+}
-339
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ListChangedBlocksInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-348
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-352
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ListChangedBlocksInputFuture;
-355
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_LISTCHANGEDBLOCKS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-363
+            }
             crate::protocol_serde::shape_list_changed_blocks::de_list_changed_blocks_http_request(
                 request,
-366
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-375
+                )
             },
         );

↧ Expand context

         ListChangedBlocksInputFuture {
             inner: Box::pin(fut),
-380
+        }
-381
+    }
-382
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ListChangedBlocksOutput
-387
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_list_changed_blocks::ser_list_changed_blocks_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-394
+                        }
-395
+                    }
-396
+    }
-397
+}

@@ -447,443 +507,502 @@

↥ Expand context

-443
+}
-444
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GetSnapshotBlockInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-453
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-457
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = GetSnapshotBlockInputFuture;
-460
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GETSNAPSHOTBLOCK,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-468
+            }
             crate::protocol_serde::shape_get_snapshot_block::de_get_snapshot_block_http_request(
                 request,
-471
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-480
+                )
             },
         );

↧ Expand context

         GetSnapshotBlockInputFuture {
             inner: Box::pin(fut),
-485
+        }
-486
+    }
-487
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GetSnapshotBlockOutput
-492
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_snapshot_block::ser_get_snapshot_block_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-501
+            }
-502
+        }

@@ -555,550 +615,609 @@

↥ Expand context

-550
+}
-551
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CompleteSnapshotInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-560
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-564
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CompleteSnapshotInputFuture;
-567
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_COMPLETESNAPSHOT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-575
+            }
             crate::protocol_serde::shape_complete_snapshot::de_complete_snapshot_http_request(
                 request,
-578
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-587
+                )
             },
         );

↧ Expand context

         CompleteSnapshotInputFuture {
             inner: Box::pin(fut),
-592
+        }
-593
+    }
-594
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CompleteSnapshotOutput
-599
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_complete_snapshot::ser_complete_snapshot_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-608
+            }
-609
+        }

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

@@ -27,27 +87,86 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::OperationWithNestedStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithNestedStructureInputFuture;
-46

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHNESTEDSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-54
+            }
             crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithNestedStructureInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-67
+        }
-68
+    }
-69
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::OperationWithNestedStructureOutput
-74
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-81
+                        }
-82
+                    }
-83
+    }
-84
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -345,344 +405,403 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-345
+    }
-346
+}
-347
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::OperationWithRequiredMembersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-356
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-360
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithRequiredMembersInputFuture;
-363

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHREQUIREDMEMBERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-371
+            }
             crate::protocol_serde::shape_operation_with_required_members::de_operation_with_required_members_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithRequiredMembersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-384
+        }
-385
+    }
-386
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::OperationWithRequiredMembersOutput
-391
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_required_members::ser_operation_with_required_members_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-398
+                        }
-399
+                    }
-400
+    }
-401
+}
-402
 static CONTENT_TYPE_OPERATIONWITHDEFAULTS: std::sync::LazyLock<::mime::Mime> =

@@ -430,428 +490,487 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-429
+    }
-430
+}
-431
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::OperationWithDefaultsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-440
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-444
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithDefaultsInputFuture;
-447

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHDEFAULTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-455
+            }
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithDefaultsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-468
+        }
-469
+    }
-470
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::OperationWithDefaultsOutput
-475
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-482
+                        }
-483
+                    }
-484
+    }
-485
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -820,817 +880,876 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-818
+    }
-819
+}
-820
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-829
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-833
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-836

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-844
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-857
+        }
-858
+    }
-859
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::ContentTypeParametersOutput
-864
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-871
+                        }
-872
+                    }
-873
+    }
-874
+}
-875
 #[allow(unreachable_code, unused_variables)]

@@ -957,953 +1017,1012 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-954
+    }
-955
+}
-956
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-965
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-969
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-972

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-980
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-993
+        }
-994
+    }
-995
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::PutWithContentEncodingOutput
-1000
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1007
+                        }
-1008
+                    }
-1009
+    }
-1010
+}
-1011
 static CONTENT_TYPE_HOSTWITHPATHOPERATION: std::sync::LazyLock<::mime::Mime> =

@@ -1042,1037 +1102,1096 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1038
+    }
-1039
+}
-1040
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1049
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1053
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-1056

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1064
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1077
+        }
-1078
+    }
-1079
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::HostWithPathOperationOutput
-1084
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1091
+                        }
-1092
+                    }
-1093
+    }
-1094
+}
-1095
 static CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION: std::sync::LazyLock<::mime::Mime> =

@@ -1127,1121 +1187,1180 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1122
+    }
-1123
+}
-1124
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1133
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1137
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-1140

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1148
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1161
+        }
-1162
+    }
-1163
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::EndpointWithHostLabelOperationOutput
-1168
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1175
+                        }
-1176
+                    }
-1177
+    }
-1178
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1288,1281 +1348,1340 @@

↥ Expand context

-1281
+}
-1282
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1291
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1295
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-1298
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1306
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-1309
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1321
+        }
-1322
+    }
-1323
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::EndpointOperationOutput
-1328
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -1430,1422 +1492,1482 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1425
+    }
-1426
+}
-1427
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1436
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1440
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = JsonUnionsInputFuture;
-1443
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1451
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         JsonUnionsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1463
+        }
-1464
+    }
-1465
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::JsonUnionsOutput
-1470
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-1482
+                )

@@ -2394,2384 +2454,2443 @@

↥ Expand context

-2384
+}
-2385
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2394
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2398
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-2401
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-2409
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-2412
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-2424
+        }
-2425
+    }
-2426
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::GreetingWithErrorsOutput
-2431
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-2438
+                        }
-2439
+                    }
-2440
+    }
-2441
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -2602,2591 +2662,2650 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2592
+    }
-2593
+}
-2594
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2603
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2607
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-2610

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-2618
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-2631
+        }
-2632
+    }
-2633
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::SimpleScalarPropertiesOutput
-2638
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-2645
+                        }
-2646
+                    }
-2647
+    }
-2648
+}
-2649
 #[allow(unreachable_code, unused_variables)]

@@ -3009,2997 +3069,3056 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2998
+    }
-2999
+}
-3000
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::EmptyInputAndEmptyOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3009
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3013
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EmptyInputAndEmptyOutputInputFuture;
-3016

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYINPUTANDEMPTYOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-3024
+            }
             crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EmptyInputAndEmptyOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-3037
+        }
-3038
+    }
-3039
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::EmptyInputAndEmptyOutputOutput
-3044
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_input_and_empty_output::ser_empty_input_and_empty_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-3051
+                        }
-3052
+                    }
-3053
+    }
-3054
+}
-3055
 #[allow(unreachable_code, unused_variables)]

@@ -3175,3162 +3235,3221 @@

↥ Expand context

-3162
+}
-3163
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::NoInputAndOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3172
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3176
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = NoInputAndOutputInputFuture;
-3179
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NOINPUTANDOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-3187
+            }
             crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_request(
                 request,
-3190
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         NoInputAndOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-3202
+        }
-3203
+    }
-3204
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::NoInputAndOutputOutput
-3209
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-3216
+                        }
-3217
+                    }
-3218
+    }
-3219
+}
-3220
 #[allow(unreachable_code, unused_variables)]

@@ -3337,3323 +3397,3382 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3324
+    }
-3325
+}
-3326
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::NoInputAndNoOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3335
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3339
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = NoInputAndNoOutputInputFuture;
-3342

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NOINPUTANDNOOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-3350
+            }
             crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         NoInputAndNoOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-3363
+        }
-3364
+    }
-3365
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::NoInputAndNoOutputOutput
-3370
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-3377
+                        }
-3378
+                    }
-3379
+    }
-3380
+}
-3381
 #[allow(unreachable_code, unused_variables)]

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

@@ -27,27 +87,86 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-46

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-54
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-67
+        }
-68
+    }
-69
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::ContentTypeParametersOutput
-74
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-81
+                        }
-82
+                    }
-83
+    }
-84
+}
-85
 #[allow(unreachable_code, unused_variables)]

@@ -164,163 +224,222 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-164
+    }
-165
+}
-166
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-175
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-179
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-182

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-190
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-203
+        }
-204
+    }
-205
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::PutWithContentEncodingOutput
-210
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-217
+                        }
-218
+                    }
-219
+    }
-220
+}
-221
 static CONTENT_TYPE_FRACTIONALSECONDS: std::sync::LazyLock<::mime::Mime> =

@@ -251,249 +311,308 @@

↥ Expand context

-249
+}
-250
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-259
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-263
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
-266
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FRACTIONALSECONDS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-274
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
-277
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         FractionalSecondsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-289
+        }
-290
+    }
-291
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::FractionalSecondsOutput
-296
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -344,341 +404,400 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-342
+    }
-343
+}
-344
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::DatetimeOffsetsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-353
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-357
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = DatetimeOffsetsInputFuture;
-360

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DATETIMEOFFSETS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-368
+            }
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         DatetimeOffsetsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-381
+        }
-382
+    }
-383
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::DatetimeOffsetsOutput
-388
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -437,433 +497,492 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-434
+    }
-435
+}
-436
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-445
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-449
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-452

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-460
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-473
+        }
-474
+    }
-475
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::HostWithPathOperationOutput
-480
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-487
+                        }
-488
+                    }
-489
+    }
-490
+}
-491
 static CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION: std::sync::LazyLock<::mime::Mime> =

@@ -522,517 +582,576 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-518
+    }
-519
+}
-520
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-529
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-533
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-536

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-544
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-557
+        }
-558
+    }
-559
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::EndpointWithHostLabelOperationOutput
-564
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-571
+                        }
-572
+                    }
-573
+    }
-574
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -688,682 +748,741 @@

↥ Expand context

-682
+}
-683
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-692
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-696
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-699
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-707
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-710
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EndpointOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-722
+        }
-723
+    }
-724
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::EndpointOperationOutput
-729
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,

@@ -832,825 +894,885 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-828
+    }
-829
+}
-830
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-839
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-843
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = JsonUnionsInputFuture;
-846
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-854
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         JsonUnionsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-866
+        }
-867
+    }
-868
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::JsonUnionsOutput
-873
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-885
+                )

@@ -1716,1707 +1776,1766 @@

↥ Expand context

-1707
+}
-1708
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1717
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1721
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-1724
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1732
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-1735
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1747
+        }
-1748
+    }
-1749
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::GreetingWithErrorsOutput
-1754
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1761
+                        }
-1762
+                    }
-1763
+    }
-1764
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -1924,1914 +1984,1973 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1915
+    }
-1916
+}
-1917
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::SparseNullsOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1926
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1930
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = SparseNullsOperationInputFuture;
-1933

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSENULLSOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-1941
+            }
             crate::protocol_serde::shape_sparse_nulls_operation::de_sparse_nulls_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         SparseNullsOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-1954
+        }
-1955
+    }
-1956
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::SparseNullsOperationOutput
-1961
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_nulls_operation::ser_sparse_nulls_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-1968
+                        }
-1969
+                    }
-1970
+    }
-1971
+}
-1972
 #[allow(unreachable_code, unused_variables)]

@@ -2186,2175 +2246,2234 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2176
+    }
-2177
+}
-2178
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::NullOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2187
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2191
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = NullOperationInputFuture;
-2194

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-2202
+            }
             crate::protocol_serde::shape_null_operation::de_null_operation_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         NullOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-2215
+        }
-2216
+    }
-2217
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::NullOperationOutput
-2222
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_operation::ser_null_operation_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-2234
+                )

@@ -2357,2345 +2419,2405 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-2348
+    }
-2349
+}
-2350
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::JsonEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2359
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2363
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = JsonEnumsInputFuture;
-2366
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONENUMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-2374
+            }
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         JsonEnumsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-2386
+        }
-2387
+    }
-2388
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::JsonEnumsOutput
-2393
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-2405
+                )

@@ -2650,2636 +2710,2695 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2637
+    }
-2638
+}
-2639
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::PutAndGetInlineDocumentsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2648
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2652
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = PutAndGetInlineDocumentsInputFuture;
-2655

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTANDGETINLINEDOCUMENTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-2663
+            }
             crate::protocol_serde::shape_put_and_get_inline_documents::de_put_and_get_inline_documents_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         PutAndGetInlineDocumentsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-2676
+        }
-2677
+    }
-2678
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::PutAndGetInlineDocumentsOutput
-2683
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_and_get_inline_documents::ser_put_and_get_inline_documents_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-2690
+                        }
-2691
+                    }
-2692
+    }
-2693
+}
-2694
 #[allow(unreachable_code, unused_variables)]

@@ -2848,2833 +2908,2892 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2834
+    }
-2835
+}
-2836
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::OperationWithOptionalInputOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2845
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2849
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = OperationWithOptionalInputOutputInputFuture;
-2852

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHOPTIONALINPUTOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-2860
+            }
             crate::protocol_serde::shape_operation_with_optional_input_output::de_operation_with_optional_input_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OperationWithOptionalInputOutputInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-2873
+        }
-2874
+    }
-2875
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::OperationWithOptionalInputOutputOutput
-2880
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_optional_input_output::ser_operation_with_optional_input_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-2887
+                        }
-2888
+                    }
-2889
+    }
-2890
+}
-2891
 #[allow(unreachable_code, unused_variables)]

@@ -3046,3030 +3106,3089 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3031
+    }
-3032
+}
-3033
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3042
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3046
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-3049

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-3057
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-3070
+        }
-3071
+    }
-3072
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::SimpleScalarPropertiesOutput
-3077
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-3084
+                        }
-3085
+                    }
-3086
+    }
-3087
+}
-3088
 #[allow(unreachable_code, unused_variables)]

@@ -3453,3436 +3513,3495 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3437
+    }
-3438
+}
-3439
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::KitchenSinkOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3448
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3452
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = KitchenSinkOperationInputFuture;
-3455

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_KITCHENSINKOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-3463
+            }
             crate::protocol_serde::shape_kitchen_sink_operation::de_kitchen_sink_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         KitchenSinkOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-3476
+        }
-3477
+    }
-3478
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::KitchenSinkOperationOutput
-3483
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_kitchen_sink_operation::ser_kitchen_sink_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-3490
+                        }
-3491
+                    }
-3492
+    }
-3493
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -11963,11945 +12023,12004 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-11946
+    }
-11947
+}
-11948
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::EmptyOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-11957
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-11961
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = EmptyOperationInputFuture;
-11964

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-11972
+            }
             crate::protocol_serde::shape_empty_operation::de_empty_operation_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         EmptyOperationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-11985
+        }
-11986
+    }
-11987
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::EmptyOperationOutput
-11992
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_operation::ser_empty_operation_http_response(self)
-11995
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),

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

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeDefaultOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeDefaultOperationInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESPONSECODEDEFAULTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_response_code_default_operation::de_response_code_default_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         ResponseCodeDefaultOperationInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeDefaultOperationOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_default_operation::ser_response_code_default_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-78
+                        }
-79
+                    }
-80
+    }
-81
+}

@@ -122,121 +182,180 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-122
+    }
-123
+}
-124
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeHttpFallbackOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-133
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-137
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeHttpFallbackOperationInputFuture;
-140

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESPONSECODEHTTPFALLBACKOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-148
+            }
             crate::protocol_serde::shape_response_code_http_fallback_operation::de_response_code_http_fallback_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-158
+                )
             },
         );

↧ Expand context

         ResponseCodeHttpFallbackOperationInputFuture {
             inner: Box::pin(fut),
-163
+        }
-164
+    }
-165
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeHttpFallbackOperationOutput
-170
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_http_fallback_operation::ser_response_code_http_fallback_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-177
+                        }
-178
+                    }
-179
+    }
-180
+}

@@ -227,225 +287,284 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-226
+    }
-227
+}
-228
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeRequiredOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-237
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-241
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeRequiredOperationInputFuture;
-244

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESPONSECODEREQUIREDOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-252
+            }
             crate::protocol_serde::shape_response_code_required_operation::de_response_code_required_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-262
+                )
             },
         );

↧ Expand context

         ResponseCodeRequiredOperationInputFuture {
             inner: Box::pin(fut),
-267
+        }
-268
+    }
-269
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeRequiredOperationOutput
-274
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_required_operation::ser_response_code_required_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-281
+                        }
-282
+                    }
-283
+    }
-284
+}

@@ -332,329 +392,388 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-330
+    }
-331
+}
-332
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RequiredHeaderCollectionOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-341
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-345
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RequiredHeaderCollectionOperationInputFuture;
-348

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_REQUIREDHEADERCOLLECTIONOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-356
+            }
             crate::protocol_serde::shape_required_header_collection_operation::de_required_header_collection_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-366
+                )
             },
         );

↧ Expand context

         RequiredHeaderCollectionOperationInputFuture {
             inner: Box::pin(fut),
-371
+        }
-372
+    }
-373
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RequiredHeaderCollectionOperationOutput
-378
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_required_header_collection_operation::ser_required_header_collection_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-385
+                        }
-386
+                    }
-387
+    }
-388
+}

@@ -432,428 +492,487 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-429
+    }
-430
+}
-431
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RequiredInnerShapeOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-440
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-444
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RequiredInnerShapeOperationInputFuture;
-447

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_REQUIREDINNERSHAPEOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-455
+            }
             crate::protocol_serde::shape_required_inner_shape_operation::de_required_inner_shape_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-465
+                )
             },
         );

↧ Expand context

         RequiredInnerShapeOperationInputFuture {
             inner: Box::pin(fut),
-470
+        }
-471
+    }
-472
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RequiredInnerShapeOperationOutput
-477
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_required_inner_shape_operation::ser_required_inner_shape_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-484
+                        }
-485
+                    }
-486
+    }
-487
+}

@@ -532,527 +592,586 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-528
+    }
-529
+}
-530
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TypeComplexityOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-539
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-543
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TypeComplexityOperationInputFuture;
-546

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TYPECOMPLEXITYOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-554
+            }
             crate::protocol_serde::shape_type_complexity_operation::de_type_complexity_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-564
+                )
             },
         );

↧ Expand context

         TypeComplexityOperationInputFuture {
             inner: Box::pin(fut),
-569
+        }
-570
+    }
-571
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TypeComplexityOperationOutput
-576
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_type_complexity_operation::ser_type_complexity_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-583
+                        }
-584
+                    }
-585
+    }
-586
+}

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

@@ -24,24 +86,84 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-27
+    }
-28
+}
-29
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::DoNothingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = DoNothingInputFuture;
-45
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DONOTHING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-53
+            }
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         DoNothingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-65
+        }
-66
+    }
-67
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::DoNothingOutput
-72
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-84
+                )

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

@@ -24,24 +86,84 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-27
+    }
-28
+}
-29
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::RpcEchoInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = RpcEchoInputFuture;
-45
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RPCECHO,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-53
+            }
             crate::protocol_serde::shape_rpc_echo::de_rpc_echo_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_rpc_echo::de_rpc_echo_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         RpcEchoInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-65
+        }
-66
+    }
-67
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::RpcEchoOutput
-72
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_rpc_echo::ser_rpc_echo_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-84
+                )

@@ -140,138 +202,198 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-141
+    }
-142
+}
-143
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::MatchInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-152
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-156
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = MatchInputFuture;
-159
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MATCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-167
+            }
             crate::protocol_serde::shape_match::de_match_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_match::de_match_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         MatchInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-179
+        }
-180
+    }
-181
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::MatchOutput
-186
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_match::ser_match_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-198
+                )

@@ -256,252 +318,312 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-255
+    }
-256
+}
-257
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::OptionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-266
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-270
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = OptionInputFuture;
-273
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPTION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-281
+            }
             crate::protocol_serde::shape_option::de_option_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_option::de_option_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         OptionInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-293
+        }
-294
+    }
-295
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::OptionOutput
-300
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_option::ser_option_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-312
+                )

@@ -346,340 +408,400 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-343
+    }
-344
+}
-345
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::ResultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-354
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-358
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = ResultInputFuture;
-361
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-369
+            }
             crate::protocol_serde::shape_result::de_result_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_result::de_result_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ResultInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-381
+        }
-382
+    }
-383
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::ResultOutput
-388
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_result::ser_result_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-400
+                )

@@ -439,431 +499,490 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-432
+    }
-433
+}
-434
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::ErrCollisionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-443
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-447
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ErrCollisionsInputFuture;
-450

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ERRCOLLISIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-458
+            }
             crate::protocol_serde::shape_err_collisions::de_err_collisions_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ErrCollisionsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-471
+        }
-472
+    }
-473
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::ErrCollisionsOutput
-478
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_err_collisions::ser_err_collisions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-490
+                )

@@ -556,547 +616,606 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-548
+    }
-549
+}
-550
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::StructureNamePunningInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-559
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-563
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = StructureNamePunningInputFuture;
-566

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STRUCTURENAMEPUNNING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-574
+            }
             crate::protocol_serde::shape_structure_name_punning::de_structure_name_punning_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         StructureNamePunningInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-587
+        }
-588
+    }
-589
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::StructureNamePunningOutput
-594
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_structure_name_punning::ser_structure_name_punning_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-601
+                        }
-602
+                    }
-603
+    }
-604
+}
-605
 #[allow(unreachable_code, unused_variables)]

@@ -693,683 +753,742 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-684
+    }
-685
+}
-686
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::ReservedWordsAsMembersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-695
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-699
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = ReservedWordsAsMembersInputFuture;
-702

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RESERVEDWORDSASMEMBERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-710
+            }
             crate::protocol_serde::shape_reserved_words_as_members::de_reserved_words_as_members_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         ReservedWordsAsMembersInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-723
+        }
-724
+    }
-725
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::ReservedWordsAsMembersOutput
-730
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_reserved_words_as_members::ser_reserved_words_as_members_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-737
+                        }
-738
+                    }
-739
+    }
-740
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

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

@@ -24,24 +86,84 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-27
+    }
-28
+}
-29
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
         B,
     > for crate::input::StructsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = StructsInputFuture;
-45
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STRUCTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-53
+            }
             crate::protocol_serde::shape_structs::de_structs_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_structs::de_structs_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         StructsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-65
+        }
-66
+    }
-67
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
     > for crate::output::StructsOutput
-72
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_structs::ser_structs_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-84
+                )

tmp-codegen-diff/codegen-server-test/pokemon-service-awsjson-server-sdk/rust-server-codegen/src/operation.rs

@@ -25,25 +87,85 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::CheckHealthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = CheckHealthInputFuture;
-46
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CHECKHEALTH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-54
+            }
             crate::protocol_serde::shape_check_health::de_check_health_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_check_health::de_check_health_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         CheckHealthInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-66
+        }
-67
+    }
-68
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::CheckHealthOutput
-73
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_check_health::ser_check_health_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-85
+                )

@@ -119,117 +179,176 @@

↥ Expand context

-117
+    }
-118
+}
-119
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::CapturePokemonInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-128
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-133
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = CapturePokemonInputFuture;
-136

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CAPTUREPOKEMON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-144
+            }
             crate::protocol_serde::shape_capture_pokemon::de_capture_pokemon_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         CapturePokemonInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-157
+        }
-158
+    }
-159
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::CapturePokemonOutput
-164
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_capture_pokemon::ser_capture_pokemon_http_response(self)
-167
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),

@@ -234,231 +296,291 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-234
+    }
-235
+}
-236
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::DoNothingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-245
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-249
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;

     type Future = DoNothingInputFuture;
-252
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DONOTHING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-260
+            }
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         DoNothingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-272
+        }
-273
+    }
-274
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::DoNothingOutput
-279
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(
                         e,
                     ),
-291
+                )

@@ -327,322 +385,379 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-323
+    }
-324
+}
-325
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
         B,
     > for crate::input::GetServerStatisticsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-334
     B::Data: Send,
     ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-338
+{
     type Rejection = ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError;
     type Future = GetServerStatisticsInputFuture;
-341

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GETSERVERSTATISTICS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection::NotAcceptable);
-349
+            }
             crate::protocol_serde::shape_get_server_statistics::de_get_server_statistics_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::aws_json::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e)
             },
         );
         GetServerStatisticsInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-362
+        }
-363
+    }
-364
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0,
     > for crate::output::GetServerStatisticsOutput
-369
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_server_statistics::ser_get_server_statistics_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::aws_json_10::AwsJson1_0>::into_response(::aws_smithy_http_server::protocol::aws_json::runtime_error::RuntimeError::from(e))
-376
+                        }
-377
+                    }
-378
+    }
-379
+}

tmp-codegen-diff/codegen-server-test/pokemon-service-server-sdk/rust-server-codegen/src/operation.rs

@@ -20,20 +82,80 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GetStorageInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = GetStorageInputFuture;
-41
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GETSTORAGE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_get_storage::de_get_storage_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_get_storage::de_get_storage_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-58
+                )
             },
         );

↧ Expand context

         GetStorageInputFuture {
             inner: Box::pin(fut),
-63
+        }
-64
+    }
-65
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GetStorageOutput
-70
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_storage::ser_get_storage_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-77
+            }
-78
+        }
-79
+    }
-80
+}

@@ -126,124 +186,183 @@

↥ Expand context

-124
+}
-125
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GetPokemonSpeciesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-134
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-138
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = GetPokemonSpeciesInputFuture;
-141
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GETPOKEMONSPECIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-149
+            }
             crate::protocol_serde::shape_get_pokemon_species::de_get_pokemon_species_http_request(
                 request,
-152
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-161
+                )
             },
         );

↧ Expand context

         GetPokemonSpeciesInputFuture {
             inner: Box::pin(fut),
-166
+        }
-167
+    }
-168
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GetPokemonSpeciesOutput
-173
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_pokemon_species::ser_get_pokemon_species_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-180
+                        }
-181
+                    }
-182
+    }
-183
+}

@@ -232,229 +292,288 @@

↥ Expand context

-229
+}
-230
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamPokemonRadioInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-239
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-243
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamPokemonRadioInputFuture;
-246
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMPOKEMONRADIO,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-254
+            }
             crate::protocol_serde::shape_stream_pokemon_radio::de_stream_pokemon_radio_http_request(
                 request,
-257
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-266
+                )
             },
         );

↧ Expand context

         StreamPokemonRadioInputFuture {
             inner: Box::pin(fut),
-271
+        }
-272
+    }
-273
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamPokemonRadioOutput
-278
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_stream_pokemon_radio::ser_stream_pokemon_radio_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-285
+                        }
-286
+                    }
-287
+    }
-288
+}

@@ -312,308 +374,368 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-311
+    }
-312
+}
-313
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CheckHealthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-322
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-326
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = CheckHealthInputFuture;
-329
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CHECKHEALTH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-337
+            }
             crate::protocol_serde::shape_check_health::de_check_health_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_check_health::de_check_health_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-346
+                )
             },
         );

↧ Expand context

         CheckHealthInputFuture {
             inner: Box::pin(fut),
-351
+        }
-352
+    }
-353
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CheckHealthOutput
-358
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_check_health::ser_check_health_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-365
+            }
-366
+        }
-367
+    }
-368
+}

@@ -402,396 +462,455 @@

↥ Expand context

-396
+    }
-397
+}
-398
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CapturePokemonInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-407
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-412
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CapturePokemonInputFuture;
-415

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CAPTUREPOKEMON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-423
+            }
             crate::protocol_serde::shape_capture_pokemon::de_capture_pokemon_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-433
+                )
             },
         );

↧ Expand context

         CapturePokemonInputFuture {
             inner: Box::pin(fut),
-438
+        }
-439
+    }
-440
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CapturePokemonOutput
-445
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_capture_pokemon::ser_capture_pokemon_http_response(self)
-448
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-453
+            }
-454
+        }
-455
+    }

@@ -503,496 +565,556 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-499
+    }
-500
+}
-501
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DoNothingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-510
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-514
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = DoNothingInputFuture;
-517
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DONOTHING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-525
+            }
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-534
+                )
             },
         );

↧ Expand context

         DoNothingInputFuture {
             inner: Box::pin(fut),
-539
+        }
-540
+    }
-541
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DoNothingOutput
-546
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-553
+            }
-554
+        }
-555
+    }
-556
+}

@@ -587,578 +647,637 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-579
+    }
-580
+}
-581
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GetServerStatisticsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-590
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-594
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = GetServerStatisticsInputFuture;
-597

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GETSERVERSTATISTICS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-605
+            }
             crate::protocol_serde::shape_get_server_statistics::de_get_server_statistics_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-615
+                )
             },
         );

↧ Expand context

         GetServerStatisticsInputFuture {
             inner: Box::pin(fut),
-620
+        }
-621
+    }
-622
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GetServerStatisticsOutput
-627
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_server_statistics::ser_get_server_statistics_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-634
+                        }
-635
+                    }
-636
+    }
-637
+}

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

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OperationWithNestedStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OperationWithNestedStructureInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHNESTEDSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         OperationWithNestedStructureInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OperationWithNestedStructureOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-78
+                        }
-79
+                    }
-80
+    }
-81
+}

@@ -336,335 +396,394 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-336
+    }
-337
+}
-338
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OperationWithDefaultsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-347
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-351
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OperationWithDefaultsInputFuture;
-354

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHDEFAULTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-362
+            }
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-372
+                )
             },
         );

↧ Expand context

         OperationWithDefaultsInputFuture {
             inner: Box::pin(fut),
-377
+        }
-378
+    }
-379
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OperationWithDefaultsOutput
-384
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-391
+                        }
-392
+                    }
-393
+    }
-394
+}

@@ -723,721 +783,780 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-722
+    }
-723
+}
-724
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-733
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-737
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-740

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-748
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-758
+                )
             },
         );

↧ Expand context

         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),
-763
+        }
-764
+    }
-765
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ContentTypeParametersOutput
-770
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-777
+                        }
-778
+                    }
-779
+    }
-780
+}

@@ -856,853 +916,912 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-854
+    }
-855
+}
-856
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-865
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-869
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-872

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-880
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-890
+                )
             },
         );

↧ Expand context

         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),
-895
+        }
-896
+    }
-897
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PutWithContentEncodingOutput
-902
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-909
+                        }
-910
+                    }
-911
+    }
-912
+}

@@ -940,936 +1000,995 @@

↥ Expand context

-936
+}
-937
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-946
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-950
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
-953
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FRACTIONALSECONDS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-961
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
-964
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-973
+                )
             },
         );

↧ Expand context

         FractionalSecondsInputFuture {
             inner: Box::pin(fut),
-978
+        }
-979
+    }
-980
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::FractionalSecondsOutput
-985
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-994
+            }
-995
+        }

@@ -1024,1019 +1084,1078 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1020
+    }
-1021
+}
-1022
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DatetimeOffsetsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1031
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1035
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DatetimeOffsetsInputFuture;
-1038

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DATETIMEOFFSETS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1046
+            }
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1056
+                )
             },
         );

↧ Expand context

         DatetimeOffsetsInputFuture {
             inner: Box::pin(fut),
-1061
+        }
-1062
+    }
-1063
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DatetimeOffsetsOutput
-1068
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1077
+            }
-1078
+        }

@@ -1108,1102 +1168,1161 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1103
+    }
-1104
+}
-1105
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPostNoInputNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1114
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1118
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPostNoInputNoPayloadInputFuture;
-1121

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTPOSTNOINPUTNOPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1129
+            }
             crate::protocol_serde::shape_test_post_no_input_no_payload::de_test_post_no_input_no_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1139
+                )
             },
         );

↧ Expand context

         TestPostNoInputNoPayloadInputFuture {
             inner: Box::pin(fut),
-1144
+        }
-1145
+    }
-1146
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPostNoInputNoPayloadOutput
-1151
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_post_no_input_no_payload::ser_test_post_no_input_no_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1158
+                        }
-1159
+                    }
-1160
+    }
-1161
+}

@@ -1242,1235 +1302,1294 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1236
+    }
-1237
+}
-1238
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestGetNoInputNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1247
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1251
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestGetNoInputNoPayloadInputFuture;
-1254

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTGETNOINPUTNOPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1262
+            }
             crate::protocol_serde::shape_test_get_no_input_no_payload::de_test_get_no_input_no_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1272
+                )
             },
         );

↧ Expand context

         TestGetNoInputNoPayloadInputFuture {
             inner: Box::pin(fut),
-1277
+        }
-1278
+    }
-1279
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestGetNoInputNoPayloadOutput
-1284
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_get_no_input_no_payload::ser_test_get_no_input_no_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1291
+                        }
-1292
+                    }
-1293
+    }
-1294
+}

@@ -1378,1370 +1438,1429 @@

↥ Expand context

-1370
+}
-1371
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPostNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1380
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1384
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPostNoPayloadInputFuture;
-1387
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTPOSTNOPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1395
+            }
             crate::protocol_serde::shape_test_post_no_payload::de_test_post_no_payload_http_request(
                 request,
-1398
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1407
+                )
             },
         );

↧ Expand context

         TestPostNoPayloadInputFuture {
             inner: Box::pin(fut),
-1412
+        }
-1413
+    }
-1414
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPostNoPayloadOutput
-1419
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_post_no_payload::ser_test_post_no_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1426
+                        }
-1427
+                    }
-1428
+    }
-1429
+}

@@ -1562,1553 +1622,1612 @@

↥ Expand context

-1553
+}
-1554
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestGetNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1563
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1567
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestGetNoPayloadInputFuture;
-1570
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTGETNOPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1578
+            }
             crate::protocol_serde::shape_test_get_no_payload::de_test_get_no_payload_http_request(
                 request,
-1581
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1590
+                )
             },
         );

↧ Expand context

         TestGetNoPayloadInputFuture {
             inner: Box::pin(fut),
-1595
+        }
-1596
+    }
-1597
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestGetNoPayloadOutput
-1602
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_get_no_payload::ser_test_get_no_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1609
+                        }
-1610
+                    }
-1611
+    }
-1612
+}

@@ -1739,1729 +1799,1788 @@

↥ Expand context

         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1734
+    }
-1735
+}
-1736
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1745
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

-1749
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadBlobInputFuture;
-1752
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_test_payload_blob::de_test_payload_blob_http_request(
                 request,
-1757
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1766
+                )
             },
         );

↧ Expand context

         TestPayloadBlobInputFuture {
             inner: Box::pin(fut),
-1771
+        }
-1772
+    }
-1773
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadBlobOutput
-1778
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_blob::ser_test_payload_blob_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1787
+            }
-1788
+        }

@@ -1929,1918 +1989,1977 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1919
+    }
-1920
+}
-1921
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1930
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1934
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadStructureInputFuture;
-1937

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTPAYLOADSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1945
+            }
             crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1955
+                )
             },
         );

↧ Expand context

         TestPayloadStructureInputFuture {
             inner: Box::pin(fut),
-1960
+        }
-1961
+    }
-1962
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadStructureOutput
-1967
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_structure::ser_test_payload_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1974
+                        }
-1975
+                    }
-1976
+    }
-1977
+}

@@ -2193,2181 +2253,2240 @@

↥ Expand context

-2181
+}
-2182
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestBodyStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2191
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2195
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestBodyStructureInputFuture;
-2198
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTBODYSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2206
+            }
             crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_request(
                 request,
-2209
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2218
+                )
             },
         );

↧ Expand context

         TestBodyStructureInputFuture {
             inner: Box::pin(fut),
-2223
+        }
-2224
+    }
-2225
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestBodyStructureOutput
-2230
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2237
+                        }
-2238
+                    }
-2239
+    }
-2240
+}

@@ -2387,2374 +2447,2433 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2375
+    }
-2376
+}
-2377
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2386
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2390
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithGenericStringInputFuture;
-2393

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHGENERICSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2401
+            }
             crate::protocol_serde::shape_malformed_accept_with_generic_string::de_malformed_accept_with_generic_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2411
+                )
             },
         );

↧ Expand context

         MalformedAcceptWithGenericStringInputFuture {
             inner: Box::pin(fut),
-2416
+        }
-2417
+    }
-2418
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithGenericStringOutput
-2423
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_generic_string::ser_malformed_accept_with_generic_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2430
+                        }
-2431
+                    }
-2432
+    }
-2433
+}

@@ -2521,2507 +2581,2566 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2508
+    }
-2509
+}
-2510
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2519
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2523
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithPayloadInputFuture;
-2526

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2534
+            }
             crate::protocol_serde::shape_malformed_accept_with_payload::de_malformed_accept_with_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2544
+                )
             },
         );

↧ Expand context

         MalformedAcceptWithPayloadInputFuture {
             inner: Box::pin(fut),
-2549
+        }
-2550
+    }
-2551
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithPayloadOutput
-2556
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_payload::ser_malformed_accept_with_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2563
+                        }
-2564
+                    }
-2565
+    }
-2566
+}

@@ -2649,2634 +2709,2693 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2635
+    }
-2636
+}
-2637
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2646
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2650
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithBodyInputFuture;
-2653

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2661
+            }
             crate::protocol_serde::shape_malformed_accept_with_body::de_malformed_accept_with_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2671
+                )
             },
         );

↧ Expand context

         MalformedAcceptWithBodyInputFuture {
             inner: Box::pin(fut),
-2676
+        }
-2677
+    }
-2678
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithBodyOutput
-2683
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_body::ser_malformed_accept_with_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2690
+                        }
-2691
+                    }
-2692
+    }
-2693
+}

@@ -2777,2761 +2837,2820 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2762
+    }
-2763
+}
-2764
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2773
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2777
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithGenericStringInputFuture;
-2780

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHGENERICSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2788
+            }
             crate::protocol_serde::shape_malformed_content_type_with_generic_string::de_malformed_content_type_with_generic_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2798
+                )
             },
         );

↧ Expand context

         MalformedContentTypeWithGenericStringInputFuture {
             inner: Box::pin(fut),
-2803
+        }
-2804
+    }
-2805
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithGenericStringOutput
-2810
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_generic_string::ser_malformed_content_type_with_generic_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2817
+                        }
-2818
+                    }
-2819
+    }
-2820
+}

@@ -2859,2842 +2919,2901 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2843
+    }
-2844
+}
-2845
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2854
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2858
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithPayloadInputFuture;
-2861

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2869
+            }
             crate::protocol_serde::shape_malformed_content_type_with_payload::de_malformed_content_type_with_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2879
+                )
             },
         );

↧ Expand context

         MalformedContentTypeWithPayloadInputFuture {
             inner: Box::pin(fut),
-2884
+        }
-2885
+    }
-2886
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithPayloadOutput
-2891
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_payload::ser_malformed_content_type_with_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2898
+                        }
-2899
+                    }
-2900
+    }
-2901
+}

@@ -3039,3021 +3099,3080 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3022
+    }
-3023
+}
-3024
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3033
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3037
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithBodyInputFuture;
-3040

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3048
+            }
             crate::protocol_serde::shape_malformed_content_type_with_body::de_malformed_content_type_with_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-3058
+                )
             },
         );

↧ Expand context

         MalformedContentTypeWithBodyInputFuture {
             inner: Box::pin(fut),
-3063
+        }
-3064
+    }
-3065
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithBodyOutput
-3070
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_body::ser_malformed_content_type_with_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3077
+                        }
-3078
+                    }
-3079
+    }
-3080
+}

@@ -3218,3199 +3278,3258 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3200
+    }
-3201
+}
-3202
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithoutBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3211
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3215
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithoutBodyInputFuture;
-3218

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHOUTBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3226
+            }
             crate::protocol_serde::shape_malformed_content_type_without_body::de_malformed_content_type_without_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-3236
+                )
             },
         );

↧ Expand context

         MalformedContentTypeWithoutBodyInputFuture {
             inner: Box::pin(fut),
-3241
+        }
-3242
+    }
-3243
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithoutBodyOutput
-3248
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_without_body::ser_malformed_content_type_without_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3255
+                        }
-3256
+                    }
-3257
+    }
-3258
+}

@@ -3351,3331 +3411,3390 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3332
+    }
-3333
+}
-3334
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3343
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3347
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyHttpDateInputFuture;
-3350

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3358
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_http_date::de_malformed_timestamp_body_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-3368
+                )
             },
         );

↧ Expand context

         MalformedTimestampBodyHttpDateInputFuture {
             inner: Box::pin(fut),
-3373
+        }
-3374
+    }
-3375
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyHttpDateOutput
-3380
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3387
+                        }
-3388
+                    }
-3389
+    }
-3390
+}

@@ -3691,3670 +3751,3729 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3671
+    }
-3672
+}
-3673
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3682
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3686
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDateTimeInputFuture;
-3689

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDATETIME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3697
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_date_time::de_malformed_timestamp_body_date_time_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-3707
+                )
             },
         );

↧ Expand context

         MalformedTimestampBodyDateTimeInputFuture {
             inner: Box::pin(fut),
-3712
+        }
-3713
+    }
-3714
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDateTimeOutput
-3719
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3726
+                        }
-3727
+                    }
-3728
+    }
-3729
+}

@@ -4704,4682 +4764,4741 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-4683
+    }
-4684
+}
-4685
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4694
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4698
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDefaultInputFuture;
-4701

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4709
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_default::de_malformed_timestamp_body_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-4719
+                )
             },
         );

↧ Expand context

         MalformedTimestampBodyDefaultInputFuture {
             inner: Box::pin(fut),
-4724
+        }
-4725
+    }
-4726
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDefaultOutput
-4731
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4738
+                        }
-4739
+                    }
-4740
+    }
-4741
+}

@@ -5563,5540 +5623,5599 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-5541
+    }
-5542
+}
-5543
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-5552
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-5556
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderEpochInputFuture;
-5559

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADEREPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5567
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_epoch::de_malformed_timestamp_header_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-5577
+                )
             },
         );

↧ Expand context

         MalformedTimestampHeaderEpochInputFuture {
             inner: Box::pin(fut),
-5582
+        }
-5583
+    }
-5584
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderEpochOutput
-5589
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5596
+                        }
-5597
+                    }
-5598
+    }
-5599
+}

@@ -6123,6099 +6183,6158 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-6100
+    }
-6101
+}
-6102
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-6111
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-6115
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDateTimeInputFuture;
-6118

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDATETIME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6126
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_date_time::de_malformed_timestamp_header_date_time_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-6136
+                )
             },
         );

↧ Expand context

         MalformedTimestampHeaderDateTimeInputFuture {
             inner: Box::pin(fut),
-6141
+        }
-6142
+    }
-6143
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDateTimeOutput
-6148
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6155
+                        }
-6156
+                    }
-6157
+    }
-6158
+}

@@ -6999,6974 +7059,7033 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-6975
+    }
-6976
+}
-6977
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-6986
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-6990
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDefaultInputFuture;
-6993

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7001
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_default::de_malformed_timestamp_header_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-7011
+                )
             },
         );

↧ Expand context

         MalformedTimestampHeaderDefaultInputFuture {
             inner: Box::pin(fut),
-7016
+        }
-7017
+    }
-7018
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDefaultOutput
-7023
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7030
+                        }
-7031
+                    }
-7032
+    }
-7033
+}

@@ -7314,7288 +7374,7347 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-7289
+    }
-7290
+}
-7291
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-7300
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-7304
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryEpochInputFuture;
-7307

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYEPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7315
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_epoch::de_malformed_timestamp_query_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-7325
+                )
             },
         );

↧ Expand context

         MalformedTimestampQueryEpochInputFuture {
             inner: Box::pin(fut),
-7330
+        }
-7331
+    }
-7332
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryEpochOutput
-7337
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7344
+                        }
-7345
+                    }
-7346
+    }
-7347
+}

@@ -7939,7912 +7999,7971 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-7913
+    }
-7914
+}
-7915
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-7924
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-7928
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryHttpDateInputFuture;
-7931

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7939
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_http_date::de_malformed_timestamp_query_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-7949
+                )
             },
         );

↧ Expand context

         MalformedTimestampQueryHttpDateInputFuture {
             inner: Box::pin(fut),
-7954
+        }
-7955
+    }
-7956
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryHttpDateOutput
-7961
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7968
+                        }
-7969
+                    }
-7970
+    }
-7971
+}

@@ -8267,8239 +8327,8298 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-8240
+    }
-8241
+}
-8242
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-8251
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-8255
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryDefaultInputFuture;
-8258

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8266
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_default::de_malformed_timestamp_query_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-8276
+                )
             },
         );

↧ Expand context

         MalformedTimestampQueryDefaultInputFuture {
             inner: Box::pin(fut),
-8281
+        }
-8282
+    }
-8283
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryDefaultOutput
-8288
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8295
+                        }
-8296
+                    }
-8297
+    }
-8298
+}

@@ -9269,9240 +9329,9299 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-9241
+    }
-9242
+}
-9243
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-9252
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-9256
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathEpochInputFuture;
-9259

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHEPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9267
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_epoch::de_malformed_timestamp_path_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-9277
+                )
             },
         );

↧ Expand context

         MalformedTimestampPathEpochInputFuture {
             inner: Box::pin(fut),
-9282
+        }
-9283
+    }
-9284
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathEpochOutput
-9289
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9296
+                        }
-9297
+                    }
-9298
+    }
-9299
+}

@@ -9858,9828 +9918,9887 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-9829
+    }
-9830
+}
-9831
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-9840
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-9844
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathHttpDateInputFuture;
-9847

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9855
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_http_date::de_malformed_timestamp_path_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-9865
+                )
             },
         );

↧ Expand context

         MalformedTimestampPathHttpDateInputFuture {
             inner: Box::pin(fut),
-9870
+        }
-9871
+    }
-9872
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathHttpDateOutput
-9877
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9884
+                        }
-9885
+                    }
-9886
+    }
-9887
+}

@@ -10168,10137 +10228,10196 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-10138
+    }
-10139
+}
-10140
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-10149
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-10153
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathDefaultInputFuture;
-10156

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-10164
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_default::de_malformed_timestamp_path_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-10174
+                )
             },
         );

↧ Expand context

         MalformedTimestampPathDefaultInputFuture {
             inner: Box::pin(fut),
-10179
+        }
-10180
+    }
-10181
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathDefaultOutput
-10186
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10193
+                        }
-10194
+                    }
-10195
+    }
-10196
+}

@@ -11106,11074 +11166,11133 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-11075
+    }
-11076
+}
-11077
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-11086
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-11090
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedStringInputFuture;
-11093

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-11101
+            }
             crate::protocol_serde::shape_malformed_string::de_malformed_string_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-11111
+                )
             },
         );

↧ Expand context

         MalformedStringInputFuture {
             inner: Box::pin(fut),
-11116
+        }
-11117
+    }
-11118
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedStringOutput
-11123
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_string::ser_malformed_string_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-11132
+            }
-11133
+        }

@@ -11371,11338 +11431,11397 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-11339
+    }
-11340
+}
-11341
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedDoubleInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-11350
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-11354
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedDoubleInputFuture;
-11357

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDDOUBLE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-11365
+            }
             crate::protocol_serde::shape_malformed_double::de_malformed_double_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-11375
+                )
             },
         );

↧ Expand context

         MalformedDoubleInputFuture {
             inner: Box::pin(fut),
-11380
+        }
-11381
+    }
-11382
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedDoubleOutput
-11387
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-11396
+            }
-11397
+        }

@@ -12169,12135 +12229,12194 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-12136
+    }
-12137
+}
-12138
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedFloatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-12147
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-12151
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedFloatInputFuture;
-12154

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDFLOAT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-12162
+            }
             crate::protocol_serde::shape_malformed_float::de_malformed_float_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-12172
+                )
             },
         );

↧ Expand context

         MalformedFloatInputFuture {
             inner: Box::pin(fut),
-12177
+        }
-12178
+    }
-12179
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedFloatOutput
-12184
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_response(self)
-12187
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-12192
+            }
-12193
+        }
-12194
+    }

@@ -12965,12930 +13025,12989 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-12931
+    }
-12932
+}
-12933
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLongInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-12942
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-12946
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLongInputFuture;
-12949

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLONG,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-12957
+            }
             crate::protocol_serde::shape_malformed_long::de_malformed_long_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-12967
+                )
             },
         );

↧ Expand context

         MalformedLongInputFuture {
             inner: Box::pin(fut),
-12972
+        }
-12973
+    }
-12974
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLongOutput
-12979
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-12986
+            }
-12987
+        }
-12988
+    }
-12989
+}

@@ -14942,14906 +15002,14965 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-14907
+    }
-14908
+}
-14909
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedShortInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-14918
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14922
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedShortInputFuture;
-14925

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDSHORT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-14933
+            }
             crate::protocol_serde::shape_malformed_short::de_malformed_short_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-14943
+                )
             },
         );

↧ Expand context

         MalformedShortInputFuture {
             inner: Box::pin(fut),
-14948
+        }
-14949
+    }
-14950
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedShortOutput
-14955
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_response(self)
-14958
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-14963
+            }
-14964
+        }
-14965
+    }

@@ -17256,17219 +17316,17278 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-17220
+    }
-17221
+}
-17222
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedByteInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-17231
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-17235
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedByteInputFuture;
-17238

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBYTE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-17246
+            }
             crate::protocol_serde::shape_malformed_byte::de_malformed_byte_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-17256
+                )
             },
         );

↧ Expand context

         MalformedByteInputFuture {
             inner: Box::pin(fut),
-17261
+        }
-17262
+    }
-17263
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedByteOutput
-17268
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-17275
+            }
-17276
+        }
-17277
+    }
-17278
+}

@@ -19569,19531 +19629,19590 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-19532
+    }
-19533
+}
-19534
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-19543
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-19547
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBlobInputFuture;
-19550

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBLOB,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-19558
+            }
             crate::protocol_serde::shape_malformed_blob::de_malformed_blob_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-19568
+                )
             },
         );

↧ Expand context

         MalformedBlobInputFuture {
             inner: Box::pin(fut),
-19573
+        }
-19574
+    }
-19575
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBlobOutput
-19580
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_blob::ser_malformed_blob_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-19587
+            }
-19588
+        }
-19589
+    }
-19590
+}

@@ -20077,20038 +20139,20098 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-20041
+    }
-20042
+}
-20043
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedMapInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-20052
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20056
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = MalformedMapInputFuture;
-20059
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDMAP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-20067
+            }
             crate::protocol_serde::shape_malformed_map::de_malformed_map_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_malformed_map::de_malformed_map_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-20076
+                )
             },
         );

↧ Expand context

         MalformedMapInputFuture {
             inner: Box::pin(fut),
-20081
+        }
-20082
+    }
-20083
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedMapOutput
-20088
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_map::ser_malformed_map_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-20095
+            }
-20096
+        }
-20097
+    }
-20098
+}

@@ -20260,20219 +20320,20278 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-20220
+    }
-20221
+}
-20222
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedListInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-20231
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20235
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedListInputFuture;
-20238

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLIST,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-20246
+            }
             crate::protocol_serde::shape_malformed_list::de_malformed_list_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-20256
+                )
             },
         );

↧ Expand context

         MalformedListInputFuture {
             inner: Box::pin(fut),
-20261
+        }
-20262
+    }
-20263
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedListOutput
-20268
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_list::ser_malformed_list_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-20275
+            }
-20276
+        }
-20277
+    }
-20278
+}

@@ -20443,20401 +20503,20460 @@

↥ Expand context

-20401
+}
-20402
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBooleanInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-20411
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20415
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBooleanInputFuture;
-20418
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBOOLEAN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-20426
+            }
             crate::protocol_serde::shape_malformed_boolean::de_malformed_boolean_http_request(
                 request,
-20429
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-20438
+                )
             },
         );

↧ Expand context

         MalformedBooleanInputFuture {
             inner: Box::pin(fut),
-20443
+        }
-20444
+    }
-20445
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBooleanOutput
-20450
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-20459
+            }
-20460
+        }

@@ -25362,25319 +25422,25378 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-25320
+    }
-25321
+}
-25322
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-25331
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-25335
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUnionInputFuture;
-25338

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDUNION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-25346
+            }
             crate::protocol_serde::shape_malformed_union::de_malformed_union_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-25356
+                )
             },
         );

↧ Expand context

         MalformedUnionInputFuture {
             inner: Box::pin(fut),
-25361
+        }
-25362
+    }
-25363
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUnionOutput
-25368
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_union::ser_malformed_union_http_response(self)
-25371
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-25376
+            }
-25377
+        }
-25378
+    }

@@ -25734,25690 +25794,25749 @@

↥ Expand context

-25690
+}
-25691
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedIntegerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-25700
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-25704
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedIntegerInputFuture;
-25707
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDINTEGER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-25715
+            }
             crate::protocol_serde::shape_malformed_integer::de_malformed_integer_http_request(
                 request,
-25718
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-25727
+                )
             },
         );

↧ Expand context

         MalformedIntegerInputFuture {
             inner: Box::pin(fut),
-25732
+        }
-25733
+    }
-25734
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedIntegerOutput
-25739
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-25748
+            }
-25749
+        }

@@ -27719,27674 +27779,27733 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-27675
+    }
-27676
+}
-27677
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRequestBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-27686
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-27690
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRequestBodyInputFuture;
-27693

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDREQUESTBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-27701
+            }
             crate::protocol_serde::shape_malformed_request_body::de_malformed_request_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-27711
+                )
             },
         );

↧ Expand context

         MalformedRequestBodyInputFuture {
             inner: Box::pin(fut),
-27716
+        }
-27717
+    }
-27718
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRequestBodyOutput
-27723
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_request_body::ser_malformed_request_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-27730
+                        }
-27731
+                    }
-27732
+    }
-27733
+}

@@ -28323,28277 +28383,28336 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28278
+    }
-28279
+}
-28280
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpChecksumRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28289
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28293
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpChecksumRequiredInputFuture;
-28296

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPCHECKSUMREQUIRED,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28304
+            }
             crate::protocol_serde::shape_http_checksum_required::de_http_checksum_required_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28314
+                )
             },
         );

↧ Expand context

         HttpChecksumRequiredInputFuture {
             inner: Box::pin(fut),
-28319
+        }
-28320
+    }
-28321
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpChecksumRequiredOutput
-28326
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_checksum_required::ser_http_checksum_required_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28333
+                        }
-28334
+                    }
-28335
+    }
-28336
+}

@@ -28461,28414 +28521,28473 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28415
+    }
-28416
+}
-28417
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28426
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28430
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-28433

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28441
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28451
+                )
             },
         );

↧ Expand context

         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),
-28456
+        }
-28457
+    }
-28458
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HostWithPathOperationOutput
-28463
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28470
+                        }
-28471
+                    }
-28472
+    }
-28473
+}

@@ -28543,28495 +28603,28554 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28496
+    }
-28497
+}
-28498
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28507
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28511
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-28514

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28522
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28532
+                )
             },
         );

↧ Expand context

         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),
-28537
+        }
-28538
+    }
-28539
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointWithHostLabelOperationOutput
-28544
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28551
+                        }
-28552
+                    }
-28553
+    }
-28554
+}

@@ -28701,28652 +28761,28711 @@

↥ Expand context

-28652
+}
-28653
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28662
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28666
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-28669
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28677
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-28680
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28689
+                )
             },
         );

↧ Expand context

         EndpointOperationInputFuture {
             inner: Box::pin(fut),
-28694
+        }
-28695
+    }
-28696
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointOperationOutput
-28701
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28710
+            }
-28711
+        }

@@ -28836,28786 +28896,28845 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28787
+    }
-28788
+}
-28789
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostUnionWithJsonNameInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28798
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28802
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostUnionWithJsonNameInputFuture;
-28805

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_POSTUNIONWITHJSONNAME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28813
+            }
             crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28823
+                )
             },
         );

↧ Expand context

         PostUnionWithJsonNameInputFuture {
             inner: Box::pin(fut),
-28828
+        }
-28829
+    }
-28830
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostUnionWithJsonNameOutput
-28835
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_post_union_with_json_name::ser_post_union_with_json_name_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28842
+                        }
-28843
+                    }
-28844
+    }
-28845
+}

@@ -29162,29111 +29222,29170 @@

↥ Expand context

-29111
+}
-29112
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostPlayerActionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-29121
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-29125
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostPlayerActionInputFuture;
-29128
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_POSTPLAYERACTION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-29136
+            }
             crate::protocol_serde::shape_post_player_action::de_post_player_action_http_request(
                 request,
-29139
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-29148
+                )
             },
         );

↧ Expand context

         PostPlayerActionInputFuture {
             inner: Box::pin(fut),
-29153
+        }
-29154
+    }
-29155
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostPlayerActionOutput
-29160
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_post_player_action::ser_post_player_action_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-29169
+            }
-29170
+        }

@@ -29326,29274 +29388,29334 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-29277
+    }
-29278
+}
-29279
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-29288
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-29292
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = JsonUnionsInputFuture;
-29295
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-29303
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-29312
+                )
             },
         );

↧ Expand context

         JsonUnionsInputFuture {
             inner: Box::pin(fut),
-29317
+        }
-29318
+    }
-29319
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonUnionsOutput
-29324
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-29331
+            }
-29332
+        }
-29333
+    }
-29334
+}

@@ -30238,30184 +30298,30243 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-30185
+    }
-30186
+}
-30187
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeAsMapValueInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30196
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30200
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeAsMapValueInputFuture;
-30203

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DOCUMENTTYPEASMAPVALUE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30211
+            }
             crate::protocol_serde::shape_document_type_as_map_value::de_document_type_as_map_value_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30221
+                )
             },
         );

↧ Expand context

         DocumentTypeAsMapValueInputFuture {
             inner: Box::pin(fut),
-30226
+        }
-30227
+    }
-30228
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeAsMapValueOutput
-30233
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type_as_map_value::ser_document_type_as_map_value_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30240
+                        }
-30241
+                    }
-30242
+    }
-30243
+}

@@ -30469,30414 +30529,30473 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-30415
+    }
-30416
+}
-30417
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeAsPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30426
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30430
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeAsPayloadInputFuture;
-30433

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DOCUMENTTYPEASPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30441
+            }
             crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30451
+                )
             },
         );

↧ Expand context

         DocumentTypeAsPayloadInputFuture {
             inner: Box::pin(fut),
-30456
+        }
-30457
+    }
-30458
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeAsPayloadOutput
-30463
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type_as_payload::ser_document_type_as_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30470
+                        }
-30471
+                    }
-30472
+    }
-30473
+}

@@ -30752,30696 +30814,30756 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-30699
+    }
-30700
+}
-30701
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30710
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30714
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = DocumentTypeInputFuture;
-30717
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DOCUMENTTYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30725
+            }
             crate::protocol_serde::shape_document_type::de_document_type_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_document_type::de_document_type_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30734
+                )
             },
         );

↧ Expand context

         DocumentTypeInputFuture {
             inner: Box::pin(fut),
-30739
+        }
-30740
+    }
-30741
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeOutput
-30746
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type::ser_document_type_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30753
+            }
-30754
+        }
-30755
+    }
-30756
+}

@@ -31355,31297 +31417,31357 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-31300
+    }
-31301
+}
-31302
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonBlobsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-31311
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-31315
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = JsonBlobsInputFuture;
-31318
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONBLOBS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-31326
+            }
             crate::protocol_serde::shape_json_blobs::de_json_blobs_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_blobs::de_json_blobs_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-31335
+                )
             },
         );

↧ Expand context

         JsonBlobsInputFuture {
             inner: Box::pin(fut),
-31340
+        }
-31341
+    }
-31342
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonBlobsOutput
-31347
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_blobs::ser_json_blobs_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-31354
+            }
-31355
+        }
-31356
+    }
-31357
+}

@@ -31523,31463 +31583,31522 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-31464
+    }
-31465
+}
-31466
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SparseJsonMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-31475
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-31479
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SparseJsonMapsInputFuture;
-31482

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSEJSONMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-31490
+            }
             crate::protocol_serde::shape_sparse_json_maps::de_sparse_json_maps_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-31500
+                )
             },
         );

↧ Expand context

         SparseJsonMapsInputFuture {
             inner: Box::pin(fut),
-31505
+        }
-31506
+    }
-31507
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SparseJsonMapsOutput
-31512
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-31521
+            }
-31522
+        }

@@ -32204,32143 +32266,32203 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-32146
+    }
-32147
+}
-32148
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-32157
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-32161
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = JsonMapsInputFuture;
-32164
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-32172
+            }
             crate::protocol_serde::shape_json_maps::de_json_maps_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_maps::de_json_maps_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-32181
+                )
             },
         );

↧ Expand context

         JsonMapsInputFuture {
             inner: Box::pin(fut),
-32186
+        }
-32187
+    }
-32188
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonMapsOutput
-32193
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_maps::ser_json_maps_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-32200
+            }
-32201
+        }
-32202
+    }
-32203
+}

@@ -32642,32579 +32702,32638 @@

↥ Expand context

-32579
+}
-32580
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SparseJsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-32589
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-32593
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SparseJsonListsInputFuture;
-32596
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSEJSONLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-32604
+            }
             crate::protocol_serde::shape_sparse_json_lists::de_sparse_json_lists_http_request(
                 request,
-32607
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-32616
+                )
             },
         );

↧ Expand context

         SparseJsonListsInputFuture {
             inner: Box::pin(fut),
-32621
+        }
-32622
+    }
-32623
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SparseJsonListsOutput
-32628
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_lists::ser_sparse_json_lists_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-32637
+            }
-32638
+        }

@@ -32817,32753 +32879,32813 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-32756
+    }
-32757
+}
-32758
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-32767
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-32771
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = JsonListsInputFuture;
-32774
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-32782
+            }
             crate::protocol_serde::shape_json_lists::de_json_lists_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_lists::de_json_lists_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-32791
+                )
             },
         );

↧ Expand context

         JsonListsInputFuture {
             inner: Box::pin(fut),
-32796
+        }
-32797
+    }
-32798
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonListsOutput
-32803
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_lists::ser_json_lists_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-32810
+            }
-32811
+        }
-32812
+    }
-32813
+}

@@ -33181,33115 +33241,33174 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-33116
+    }
-33117
+}
-33118
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RecursiveShapesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33127
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33131
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RecursiveShapesInputFuture;
-33134

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RECURSIVESHAPES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33142
+            }
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33152
+                )
             },
         );

↧ Expand context

         RecursiveShapesInputFuture {
             inner: Box::pin(fut),
-33157
+        }
-33158
+    }
-33159
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RecursiveShapesOutput
-33164
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33173
+            }
-33174
+        }

@@ -33415,33348 +33475,33407 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-33349
+    }
-33350
+}
-33351
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonIntEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33360
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33364
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonIntEnumsInputFuture;
-33367

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONINTENUMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33375
+            }
             crate::protocol_serde::shape_json_int_enums::de_json_int_enums_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33385
+                )
             },
         );

↧ Expand context

         JsonIntEnumsInputFuture {
             inner: Box::pin(fut),
-33390
+        }
-33391
+    }
-33392
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonIntEnumsOutput
-33397
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33404
+            }
-33405
+        }
-33406
+    }
-33407
+}

@@ -33622,33554 +33684,33614 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-33557
+    }
-33558
+}
-33559
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33568
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33572
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = JsonEnumsInputFuture;
-33575
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONENUMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33583
+            }
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33592
+                )
             },
         );

↧ Expand context

         JsonEnumsInputFuture {
             inner: Box::pin(fut),
-33597
+        }
-33598
+    }
-33599
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonEnumsOutput
-33604
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33611
+            }
-33612
+        }
-33613
+    }
-33614
+}

@@ -33899,33829 +33959,33888 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-33830
+    }
-33831
+}
-33832
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonTimestampsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33841
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33845
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonTimestampsInputFuture;
-33848

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONTIMESTAMPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33856
+            }
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33866
+                )
             },
         );

↧ Expand context

         JsonTimestampsInputFuture {
             inner: Box::pin(fut),
-33871
+        }
-33872
+    }
-33873
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonTimestampsOutput
-33878
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_http_response(self)
-33881
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33886
+            }
-33887
+        }
-33888
+    }

@@ -34694,34623 +34754,34682 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-34624
+    }
-34625
+}
-34626
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34635
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34639
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-34642

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-34650
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34660
+                )
             },
         );

↧ Expand context

         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),
-34665
+        }
-34666
+    }
-34667
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SimpleScalarPropertiesOutput
-34672
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-34679
+                        }
-34680
+                    }
-34681
+    }
-34682
+}

@@ -35595,35523 +35655,35582 @@

↥ Expand context

-35523
+}
-35524
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35533
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35537
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-35540
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35548
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-35551
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35560
+                )
             },
         );

↧ Expand context

         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),
-35565
+        }
-35566
+    }
-35567
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GreetingWithErrorsOutput
-35572
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-35579
+                        }
-35580
+                    }
-35581
+    }
-35582
+}

@@ -35845,35772 +35905,35831 @@

↥ Expand context

-35772
+    }
-35773
+}
-35774
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35783
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35788
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsWithMediaTypeInputFuture;
-35791

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGTRAITSWITHMEDIATYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35799
+            }
             crate::protocol_serde::shape_streaming_traits_with_media_type::de_streaming_traits_with_media_type_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35809
+                )
             },
         );

↧ Expand context

         StreamingTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
-35814
+        }
-35815
+    }
-35816
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsWithMediaTypeOutput
-35821
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits_with_media_type::ser_streaming_traits_with_media_type_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-35828
+                        }
-35829
+                    }
-35830
+    }
-35831
+}

@@ -36026,35952 +36086,36011 @@

↥ Expand context

-35952
+    }
-35953
+}
-35954
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsRequireLengthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35963
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35968
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsRequireLengthInputFuture;
-35971

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGTRAITSREQUIRELENGTH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35979
+            }
             crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35989
+                )
             },
         );

↧ Expand context

         StreamingTraitsRequireLengthInputFuture {
             inner: Box::pin(fut),
-35994
+        }
-35995
+    }
-35996
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsRequireLengthOutput
-36001
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits_require_length::ser_streaming_traits_require_length_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36008
+                        }
-36009
+                    }
-36010
+    }
-36011
+}

@@ -36231,36156 +36291,36215 @@

↥ Expand context

-36156
+    }
-36157
+}
-36158
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36167
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36172
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsInputFuture;
-36175

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGTRAITS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36183
+            }
             crate::protocol_serde::shape_streaming_traits::de_streaming_traits_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36193
+                )
             },
         );

↧ Expand context

         StreamingTraitsInputFuture {
             inner: Box::pin(fut),
-36198
+        }
-36199
+    }
-36200
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsOutput
-36205
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits::ser_streaming_traits_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36214
+            }
-36215
+        }

@@ -36501,36425 +36561,36484 @@

↥ Expand context

-36425
+}
-36426
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpResponseCodeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36435
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36439
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpResponseCodeInputFuture;
-36442
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPRESPONSECODE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36450
+            }
             crate::protocol_serde::shape_http_response_code::de_http_response_code_http_request(
                 request,
-36453
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36462
+                )
             },
         );

↧ Expand context

         HttpResponseCodeInputFuture {
             inner: Box::pin(fut),
-36467
+        }
-36468
+    }
-36469
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpResponseCodeOutput
-36474
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_response_code::ser_http_response_code_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36483
+            }
-36484
+        }

@@ -36655,36578 +36715,36637 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-36579
+    }
-36580
+}
-36581
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadWithUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36590
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36594
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadWithUnionInputFuture;
-36597

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPAYLOADWITHUNION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36605
+            }
             crate::protocol_serde::shape_http_payload_with_union::de_http_payload_with_union_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36615
+                )
             },
         );

↧ Expand context

         HttpPayloadWithUnionInputFuture {
             inner: Box::pin(fut),
-36620
+        }
-36621
+    }
-36622
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadWithUnionOutput
-36627
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_with_union::ser_http_payload_with_union_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36634
+                        }
-36635
+                    }
-36636
+    }
-36637
+}

@@ -36903,36825 +36963,36884 @@

↥ Expand context

-36825
+}
-36826
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpStringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36835
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36839
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpStringPayloadInputFuture;
-36842
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPSTRINGPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36850
+            }
             crate::protocol_serde::shape_http_string_payload::de_http_string_payload_http_request(
                 request,
-36853
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36862
+                )
             },
         );

↧ Expand context

         HttpStringPayloadInputFuture {
             inner: Box::pin(fut),
-36867
+        }
-36868
+    }
-36869
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpStringPayloadOutput
-36874
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_string_payload::ser_http_string_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36881
+                        }
-36882
+                    }
-36883
+    }
-36884
+}

@@ -37209,37130 +37269,37189 @@

↥ Expand context

-37130
+}
-37131
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpEnumPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-37140
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-37144
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpEnumPayloadInputFuture;
-37147
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPENUMPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-37155
+            }
             crate::protocol_serde::shape_http_enum_payload::de_http_enum_payload_http_request(
                 request,
-37158
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-37167
+                )
             },
         );

↧ Expand context

         HttpEnumPayloadInputFuture {
             inner: Box::pin(fut),
-37172
+        }
-37173
+    }
-37174
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpEnumPayloadOutput
-37179
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-37188
+            }
-37189
+        }

@@ -37402,37322 +37462,37381 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-37323
+    }
-37324
+}
-37325
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadWithStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-37334
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-37338
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadWithStructureInputFuture;
-37341

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPAYLOADWITHSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-37349
+            }
             crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-37359
+                )
             },
         );

↧ Expand context

         HttpPayloadWithStructureInputFuture {
             inner: Box::pin(fut),
-37364
+        }
-37365
+    }
-37366
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadWithStructureOutput
-37371
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_with_structure::ser_http_payload_with_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-37378
+                        }
-37379
+                    }
-37380
+    }
-37381
+}

@@ -37582,37501 +37642,37560 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-37502
+    }
-37503
+}
-37504
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-37513
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-37517
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraitsWithMediaTypeInputFuture;
-37520

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPAYLOADTRAITSWITHMEDIATYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-37528
+            }
             crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_type_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-37538
+                )
             },
         );

↧ Expand context

         HttpPayloadTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
-37543
+        }
-37544
+    }
-37545
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsWithMediaTypeOutput
-37550
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits_with_media_type::ser_http_payload_traits_with_media_type_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-37557
+                        }
-37558
+                    }
-37559
+    }
-37560
+}

@@ -37749,37667 +37809,37726 @@

↥ Expand context

         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-37672
+    }
-37673
+}
-37674
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-37683
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,

-37687
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraitsInputFuture;
-37690
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_http_payload_traits::de_http_payload_traits_http_request(
                 request,
-37695
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-37704
+                )
             },
         );

↧ Expand context

         HttpPayloadTraitsInputFuture {
             inner: Box::pin(fut),
-37709
+        }
-37710
+    }
-37711
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsOutput
-37716
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits::ser_http_payload_traits_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-37723
+                        }
-37724
+                    }
-37725
+    }
-37726
+}

@@ -38157,38074 +38217,38133 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-38075
+    }
-38076
+}
-38077
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersInResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38086
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38090
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersInResponseInputFuture;
-38093

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPREFIXHEADERSINRESPONSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38101
+            }
             crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38111
+                )
             },
         );

↧ Expand context

         HttpPrefixHeadersInResponseInputFuture {
             inner: Box::pin(fut),
-38116
+        }
-38117
+    }
-38118
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersInResponseOutput
-38123
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers_in_response::ser_http_prefix_headers_in_response_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38130
+                        }
-38131
+                    }
-38132
+    }
-38133
+}

@@ -38272,38188 +38332,38247 @@

↥ Expand context

-38188
+}
-38189
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38198
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38202
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersInputFuture;
-38205
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPREFIXHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38213
+            }
             crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_http_request(
                 request,
-38216
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38225
+                )
             },
         );

↧ Expand context

         HttpPrefixHeadersInputFuture {
             inner: Box::pin(fut),
-38230
+        }
-38231
+    }
-38232
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersOutput
-38237
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers::ser_http_prefix_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38244
+                        }
-38245
+                    }
-38246
+    }
-38247
+}

@@ -38459,38374 +38519,38433 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-38375
+    }
-38376
+}
-38377
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsAsStringListMapInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38386
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38390
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsAsStringListMapInputFuture;
-38393

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSASSTRINGLISTMAP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38401
+            }
             crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38411
+                )
             },
         );

↧ Expand context

         QueryParamsAsStringListMapInputFuture {
             inner: Box::pin(fut),
-38416
+        }
-38417
+    }
-38418
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsAsStringListMapOutput
-38423
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_as_string_list_map::ser_query_params_as_string_list_map_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38430
+                        }
-38431
+                    }
-38432
+    }
-38433
+}

@@ -38605,38519 +38665,38578 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-38520
+    }
-38521
+}
-38522
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38531
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38535
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
-38538

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPRECEDENCE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38546
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38556
+                )
             },
         );

↧ Expand context

         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-38561
+        }
-38562
+    }
-38563
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
-38568
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38577
+            }
-38578
+        }

@@ -38746,38659 +38806,38718 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-38660
+    }
-38661
+}
-38662
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryIdempotencyTokenAutoFillInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38671
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38675
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryIdempotencyTokenAutoFillInputFuture;
-38678

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYIDEMPOTENCYTOKENAUTOFILL,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38686
+            }
             crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38696
+                )
             },
         );

↧ Expand context

         QueryIdempotencyTokenAutoFillInputFuture {
             inner: Box::pin(fut),
-38701
+        }
-38702
+    }
-38703
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryIdempotencyTokenAutoFillOutput
-38708
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_idempotency_token_auto_fill::ser_query_idempotency_token_auto_fill_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38715
+                        }
-38716
+                    }
-38717
+    }
-38718
+}

@@ -38828,38740 +38888,38799 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-38741
+    }
-38742
+}
-38743
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OmitsSerializingEmptyListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38752
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38756
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OmitsSerializingEmptyListsInputFuture;
-38759

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OMITSSERIALIZINGEMPTYLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38767
+            }
             crate::protocol_serde::shape_omits_serializing_empty_lists::de_omits_serializing_empty_lists_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38777
+                )
             },
         );

↧ Expand context

         OmitsSerializingEmptyListsInputFuture {
             inner: Box::pin(fut),
-38782
+        }
-38783
+    }
-38784
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OmitsSerializingEmptyListsOutput
-38789
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38796
+                        }
-38797
+                    }
-38798
+    }
-38799
+}

@@ -38987,38898 +39047,38957 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-38899
+    }
-38900
+}
-38901
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OmitsNullSerializesEmptyStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38910
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38914
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OmitsNullSerializesEmptyStringInputFuture;
-38917

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OMITSNULLSERIALIZESEMPTYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38925
+            }
             crate::protocol_serde::shape_omits_null_serializes_empty_string::de_omits_null_serializes_empty_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38935
+                )
             },
         );

↧ Expand context

         OmitsNullSerializesEmptyStringInputFuture {
             inner: Box::pin(fut),
-38940
+        }
-38941
+    }
-38942
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OmitsNullSerializesEmptyStringOutput
-38947
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_null_serializes_empty_string::ser_omits_null_serializes_empty_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38954
+                        }
-38955
+                    }
-38956
+    }
-38957
+}

@@ -39172,39082 +39232,39141 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-39083
+    }
-39084
+}
-39085
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::IgnoreQueryParamsInResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39094
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39098
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = IgnoreQueryParamsInResponseInputFuture;
-39101

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_IGNOREQUERYPARAMSINRESPONSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39109
+            }
             crate::protocol_serde::shape_ignore_query_params_in_response::de_ignore_query_params_in_response_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39119
+                )
             },
         );

↧ Expand context

         IgnoreQueryParamsInResponseInputFuture {
             inner: Box::pin(fut),
-39124
+        }
-39125
+    }
-39126
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::IgnoreQueryParamsInResponseOutput
-39131
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_ignore_query_params_in_response::ser_ignore_query_params_in_response_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39138
+                        }
-39139
+                    }
-39140
+    }
-39141
+}

@@ -39291,39200 +39351,39259 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-39201
+    }
-39202
+}
-39203
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstantAndVariableQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39212
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39216
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstantAndVariableQueryStringInputFuture;
-39219

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTANTANDVARIABLEQUERYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39227
+            }
             crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39237
+                )
             },
         );

↧ Expand context

         ConstantAndVariableQueryStringInputFuture {
             inner: Box::pin(fut),
-39242
+        }
-39243
+    }
-39244
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstantAndVariableQueryStringOutput
-39249
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_and_variable_query_string::ser_constant_and_variable_query_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39256
+                        }
-39257
+                    }
-39258
+    }
-39259
+}

@@ -39480,39388 +39540,39447 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-39389
+    }
-39390
+}
-39391
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstantQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39400
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39404
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstantQueryStringInputFuture;
-39407

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTANTQUERYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39415
+            }
             crate::protocol_serde::shape_constant_query_string::de_constant_query_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39425
+                )
             },
         );

↧ Expand context

         ConstantQueryStringInputFuture {
             inner: Box::pin(fut),
-39430
+        }
-39431
+    }
-39432
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstantQueryStringOutput
-39437
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39444
+                        }
-39445
+                    }
-39446
+    }
-39447
+}

@@ -39631,39538 +39691,39597 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-39539
+    }
-39540
+}
-39541
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::AllQueryStringTypesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39550
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39554
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = AllQueryStringTypesInputFuture;
-39557

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ALLQUERYSTRINGTYPES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39565
+            }
             crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39575
+                )
             },
         );

↧ Expand context

         AllQueryStringTypesInputFuture {
             inner: Box::pin(fut),
-39580
+        }
-39581
+    }
-39582
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::AllQueryStringTypesOutput
-39587
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39594
+                        }
-39595
+                    }
-39596
+    }
-39597
+}

@@ -41034,40940 +41094,40999 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-40941
+    }
-40942
+}
-40943
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithRegexLiteralInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-40952
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-40956
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithRegexLiteralInputFuture;
-40959

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHREGEXLITERAL,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-40967
+            }
             crate::protocol_serde::shape_http_request_with_regex_literal::de_http_request_with_regex_literal_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-40977
+                )
             },
         );

↧ Expand context

         HttpRequestWithRegexLiteralInputFuture {
             inner: Box::pin(fut),
-40982
+        }
-40983
+    }
-40984
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithRegexLiteralOutput
-40989
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-40996
+                        }
-40997
+                    }
-40998
+    }
-40999
+}

@@ -41186,41091 +41246,41150 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-41092
+    }
-41093
+}
-41094
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithFloatLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-41103
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-41107
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithFloatLabelsInputFuture;
-41110

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHFLOATLABELS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-41118
+            }
             crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-41128
+                )
             },
         );

↧ Expand context

         HttpRequestWithFloatLabelsInputFuture {
             inner: Box::pin(fut),
-41133
+        }
-41134
+    }
-41135
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithFloatLabelsOutput
-41140
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-41147
+                        }
-41148
+                    }
-41149
+    }
-41150
+}

@@ -41462,41366 +41522,41425 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-41367
+    }
-41368
+}
-41369
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithGreedyLabelInPathInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-41378
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-41382
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithGreedyLabelInPathInputFuture;
-41385

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHGREEDYLABELINPATH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-41393
+            }
             crate::protocol_serde::shape_http_request_with_greedy_label_in_path::de_http_request_with_greedy_label_in_path_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-41403
+                )
             },
         );

↧ Expand context

         HttpRequestWithGreedyLabelInPathInputFuture {
             inner: Box::pin(fut),
-41408
+        }
-41409
+    }
-41410
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithGreedyLabelInPathOutput
-41415
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_greedy_label_in_path::ser_http_request_with_greedy_label_in_path_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-41422
+                        }
-41423
+                    }
-41424
+    }
-41425
+}

@@ -41615,41518 +41675,41577 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-41519
+    }
-41520
+}
-41521
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithLabelsAndTimestampFormatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-41530
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-41534
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithLabelsAndTimestampFormatInputFuture;
-41537

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHLABELSANDTIMESTAMPFORMAT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-41545
+            }
             crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::de_http_request_with_labels_and_timestamp_format_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-41555
+                )
             },
         );

↧ Expand context

         HttpRequestWithLabelsAndTimestampFormatInputFuture {
             inner: Box::pin(fut),
-41560
+        }
-41561
+    }
-41562
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithLabelsAndTimestampFormatOutput
-41567
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::ser_http_request_with_labels_and_timestamp_format_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-41574
+                        }
-41575
+                    }
-41576
+    }
-41577
+}

@@ -41792,41694 +41852,41753 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-41695
+    }
-41696
+}
-41697
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-41706
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-41710
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithLabelsInputFuture;
-41713

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHLABELS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-41721
+            }
             crate::protocol_serde::shape_http_request_with_labels::de_http_request_with_labels_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-41731
+                )
             },
         );

↧ Expand context

         HttpRequestWithLabelsInputFuture {
             inner: Box::pin(fut),
-41736
+        }
-41737
+    }
-41738
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithLabelsOutput
-41743
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-41750
+                        }
-41751
+                    }
-41752
+    }
-41753
+}

@@ -42089,41990 +42149,42049 @@

↥ Expand context

-41990
+}
-41991
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MediaTypeHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-42000
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42004
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MediaTypeHeaderInputFuture;
-42007
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MEDIATYPEHEADER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-42015
+            }
             crate::protocol_serde::shape_media_type_header::de_media_type_header_http_request(
                 request,
-42018
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42027
+                )
             },
         );

↧ Expand context

         MediaTypeHeaderInputFuture {
             inner: Box::pin(fut),
-42032
+        }
-42033
+    }
-42034
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MediaTypeHeaderOutput
-42039
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_media_type_header::ser_media_type_header_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42048
+            }
-42049
+        }

@@ -42247,42147 +42307,42206 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-42148
+    }
-42149
+}
-42150
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TimestampFormatHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-42159
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42163
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TimestampFormatHeadersInputFuture;
-42166

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TIMESTAMPFORMATHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-42174
+            }
             crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42184
+                )
             },
         );

↧ Expand context

         TimestampFormatHeadersInputFuture {
             inner: Box::pin(fut),
-42189
+        }
-42190
+    }
-42191
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TimestampFormatHeadersOutput
-42196
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_timestamp_format_headers::ser_timestamp_format_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42203
+                        }
-42204
+                    }
-42205
+    }
-42206
+}

@@ -42477,42376 +42537,42435 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-42377
+    }
-42378
+}
-42379
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullAndEmptyHeadersServerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-42388
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42392
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullAndEmptyHeadersServerInputFuture;
-42395

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLANDEMPTYHEADERSSERVER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-42403
+            }
             crate::protocol_serde::shape_null_and_empty_headers_server::de_null_and_empty_headers_server_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42413
+                )
             },
         );

↧ Expand context

         NullAndEmptyHeadersServerInputFuture {
             inner: Box::pin(fut),
-42418
+        }
-42419
+    }
-42420
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullAndEmptyHeadersServerOutput
-42425
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_and_empty_headers_server::ser_null_and_empty_headers_server_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42432
+                        }
-42433
+                    }
-42434
+    }
-42435
+}

@@ -42587,42485 +42647,42544 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-42486
+    }
-42487
+}
-42488
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullAndEmptyHeadersClientInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-42497
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42501
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullAndEmptyHeadersClientInputFuture;
-42504

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLANDEMPTYHEADERSCLIENT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-42512
+            }
             crate::protocol_serde::shape_null_and_empty_headers_client::de_null_and_empty_headers_client_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42522
+                )
             },
         );

↧ Expand context

         NullAndEmptyHeadersClientInputFuture {
             inner: Box::pin(fut),
-42527
+        }
-42528
+    }
-42529
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullAndEmptyHeadersClientOutput
-42534
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_and_empty_headers_client::ser_null_and_empty_headers_client_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42541
+                        }
-42542
+                    }
-42543
+    }
-42544
+}

@@ -42669,42566 +42729,42625 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-42567
+    }
-42568
+}
-42569
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::InputAndOutputWithHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-42578
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42582
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = InputAndOutputWithHeadersInputFuture;
-42585

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_INPUTANDOUTPUTWITHHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-42593
+            }
             crate::protocol_serde::shape_input_and_output_with_headers::de_input_and_output_with_headers_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42603
+                )
             },
         );

↧ Expand context

         InputAndOutputWithHeadersInputFuture {
             inner: Box::pin(fut),
-42608
+        }
-42609
+    }
-42610
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::InputAndOutputWithHeadersOutput
-42615
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42622
+                        }
-42623
+                    }
-42624
+    }
-42625
+}

@@ -45047,44943 +45107,45002 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-44944
+    }
-44945
+}
-44946
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::UnitInputAndOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-44955
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-44959
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = UnitInputAndOutputInputFuture;
-44962

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_UNITINPUTANDOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-44970
+            }
             crate::protocol_serde::shape_unit_input_and_output::de_unit_input_and_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-44980
+                )
             },
         );

↧ Expand context

         UnitInputAndOutputInputFuture {
             inner: Box::pin(fut),
-44985
+        }
-44986
+    }
-44987
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::UnitInputAndOutputOutput
-44992
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_unit_input_and_output::ser_unit_input_and_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-44999
+                        }
-45000
+                    }
-45001
+    }
-45002
+}

@@ -45245,45140 +45305,45199 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-45141
+    }
-45142
+}
-45143
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyInputAndEmptyOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-45152
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-45156
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyInputAndEmptyOutputInputFuture;
-45159

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYINPUTANDEMPTYOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-45167
+            }
             crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-45177
+                )
             },
         );

↧ Expand context

         EmptyInputAndEmptyOutputInputFuture {
             inner: Box::pin(fut),
-45182
+        }
-45183
+    }
-45184
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyInputAndEmptyOutputOutput
-45189
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_input_and_empty_output::ser_empty_input_and_empty_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-45196
+                        }
-45197
+                    }
-45198
+    }
-45199
+}

@@ -45457,45351 +45517,45410 @@

↥ Expand context

-45351
+}
-45352
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NoInputAndOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-45361
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-45365
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NoInputAndOutputInputFuture;
-45368
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NOINPUTANDOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-45376
+            }
             crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_request(
                 request,
-45379
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-45388
+                )
             },
         );

↧ Expand context

         NoInputAndOutputInputFuture {
             inner: Box::pin(fut),
-45393
+        }
-45394
+    }
-45395
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NoInputAndOutputOutput
-45400
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-45407
+                        }
-45408
+                    }
-45409
+    }
-45410
+}

@@ -45662,45555 +45722,45614 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-45556
+    }
-45557
+}
-45558
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NoInputAndNoOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-45567
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-45571
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NoInputAndNoOutputInputFuture;
-45574

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NOINPUTANDNOOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-45582
+            }
             crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-45592
+                )
             },
         );

↧ Expand context

         NoInputAndNoOutputInputFuture {
             inner: Box::pin(fut),
-45597
+        }
-45598
+    }
-45599
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NoInputAndNoOutputOutput
-45604
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-45611
+                        }
-45612
+                    }
-45613
+    }
-45614
+}

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

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPRECEDENCE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-80
+            }
-81
+        }

@@ -213,212 +273,271 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-213
+    }
-214
+}
-215
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyStructWithContentOnWireOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-224
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-228
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyStructWithContentOnWireOpInputFuture;
-231

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYSTRUCTWITHCONTENTONWIREOP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-239
+            }
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-249
+                )
             },
         );

↧ Expand context

         EmptyStructWithContentOnWireOpInputFuture {
             inner: Box::pin(fut),
-254
+        }
-255
+    }
-256
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyStructWithContentOnWireOpOutput
-261
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-268
+                        }
-269
+                    }
-270
+    }
-271
+}

@@ -346,344 +406,403 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-345
+    }
-346
+}
-347
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CaseInsensitiveErrorOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-356
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-360
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CaseInsensitiveErrorOperationInputFuture;
-363

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CASEINSENSITIVEERROROPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-371
+            }
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-381
+                )
             },
         );

↧ Expand context

         CaseInsensitiveErrorOperationInputFuture {
             inner: Box::pin(fut),
-386
+        }
-387
+    }
-388
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CaseInsensitiveErrorOperationOutput
-393
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-400
+                        }
-401
+                    }
-402
+    }
-403
+}

@@ -481,478 +541,537 @@

↥ Expand context

-478
+}
-479
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullInNonSparseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-488
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-492
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullInNonSparseInputFuture;
-495
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLINNONSPARSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-503
+            }
             crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(
                 request,
-506
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-515
+                )
             },
         );

↧ Expand context

         NullInNonSparseInputFuture {
             inner: Box::pin(fut),
-520
+        }
-521
+    }
-522
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullInNonSparseOutput
-527
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-536
+            }
-537
+        }

@@ -620,616 +680,675 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-617
+    }
-618
+}
-619
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EscapedStringValuesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-628
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-632
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EscapedStringValuesInputFuture;
-635

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ESCAPEDSTRINGVALUES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-643
+            }
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-653
+                )
             },
         );

↧ Expand context

         EscapedStringValuesInputFuture {
             inner: Box::pin(fut),
-658
+        }
-659
+    }
-660
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EscapedStringValuesOutput
-665
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-672
+                        }
-673
+                    }
-674
+    }
-675
+}

@@ -834,829 +894,888 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-830
+    }
-831
+}
-832
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-841
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-845
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntOpInputFuture;
-848

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PRIMITIVEINTOP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-856
+            }
             crate::protocol_serde::shape_primitive_int_op::de_primitive_int_op_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-866
+                )
             },
         );

↧ Expand context

         PrimitiveIntOpInputFuture {
             inner: Box::pin(fut),
-871
+        }
-872
+    }
-873
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntOpOutput
-878
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_op::ser_primitive_int_op_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-887
+            }
-888
+        }

@@ -974,968 +1034,1027 @@

↥ Expand context

-968
+}
-969
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MapWithEnumKeyOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-978
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-982
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MapWithEnumKeyOpInputFuture;
-985
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MAPWITHENUMKEYOP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-993
+            }
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_request(
                 request,
-996
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1005
+                )
             },
         );

↧ Expand context

         MapWithEnumKeyOpInputFuture {
             inner: Box::pin(fut),
-1010
+        }
-1011
+    }
-1012
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MapWithEnumKeyOpOutput
-1017
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1024
+                        }
-1025
+                    }
-1026
+    }
-1027
+}

@@ -1199,1192 +1259,1251 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1193
+    }
-1194
+}
-1195
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StatusResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1204
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1208
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StatusResponseInputFuture;
-1211

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STATUSRESPONSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1219
+            }
             crate::protocol_serde::shape_status_response::de_status_response_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1229
+                )
             },
         );

↧ Expand context

         StatusResponseInputFuture {
             inner: Box::pin(fut),
-1234
+        }
-1235
+    }
-1236
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StatusResponseOutput
-1241
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_response(self)
-1244
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1249
+            }
-1250
+        }
-1251
+    }

@@ -1333,1325 +1395,1385 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1328
+    }
-1329
+}
-1330
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EnumQueryInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1339
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1343
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = EnumQueryInputFuture;
-1346
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENUMQUERY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1354
+            }
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1363
+                )
             },
         );

↧ Expand context

         EnumQueryInputFuture {
             inner: Box::pin(fut),
-1368
+        }
-1369
+    }
-1370
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EnumQueryOutput
-1375
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1382
+            }
-1383
+        }
-1384
+    }
-1385
+}

@@ -1514,1504 +1574,1563 @@

↥ Expand context

-1504
+}
-1505
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1514
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1518
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntHeaderInputFuture;
-1521
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PRIMITIVEINTHEADER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1529
+            }
             crate::protocol_serde::shape_primitive_int_header::de_primitive_int_header_http_request(
                 request,
-1532
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1541
+                )
             },
         );

↧ Expand context

         PrimitiveIntHeaderInputFuture {
             inner: Box::pin(fut),
-1546
+        }
-1547
+    }
-1548
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntHeaderOutput
-1553
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1560
+                        }
-1561
+                    }
-1562
+    }
-1563
+}

@@ -1686,1675 +1746,1734 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1676
+    }
-1677
+}
-1678
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1687
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1691
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StringPayloadInputFuture;
-1694

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STRINGPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1702
+            }
             crate::protocol_serde::shape_string_payload::de_string_payload_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1712
+                )
             },
         );

↧ Expand context

         StringPayloadInputFuture {
             inner: Box::pin(fut),
-1717
+        }
-1718
+    }
-1719
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StringPayloadOutput
-1724
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1731
+            }
-1732
+        }
-1733
+    }
-1734
+}

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

@@ -24,24 +84,83 @@

↥ Expand context

-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SensitiveValidationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SensitiveValidationInputFuture;
-41
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SENSITIVEVALIDATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_sensitive_validation::de_sensitive_validation_http_request(
                 request,
-52
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-61
+                )
             },
         );

↧ Expand context

         SensitiveValidationInputFuture {
             inner: Box::pin(fut),
-66
+        }
-67
+    }
-68
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SensitiveValidationOutput
-73
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sensitive_validation::ser_sensitive_validation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-80
+                        }
-81
+                    }
-82
+    }
-83
+}

@@ -188,187 +248,246 @@

↥ Expand context

-187
+}
-188
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RecursiveStructuresInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-197
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-201
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RecursiveStructuresInputFuture;
-204
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RECURSIVESTRUCTURES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-212
+            }
             crate::protocol_serde::shape_recursive_structures::de_recursive_structures_http_request(
                 request,
-215
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-224
+                )
             },
         );

↧ Expand context

         RecursiveStructuresInputFuture {
             inner: Box::pin(fut),
-229
+        }
-230
+    }
-231
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RecursiveStructuresOutput
-236
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_structures::ser_recursive_structures_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-243
+                        }
-244
+                    }
-245
+    }
-246
+}

@@ -403,401 +463,460 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-402
+    }
-403
+}
-404
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUniqueItemsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-413
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-417
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUniqueItemsInputFuture;
-420

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDUNIQUEITEMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-428
+            }
             crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-438
+                )
             },
         );

↧ Expand context

         MalformedUniqueItemsInputFuture {
             inner: Box::pin(fut),
-443
+        }
-444
+    }
-445
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUniqueItemsOutput
-450
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_unique_items::ser_malformed_unique_items_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-457
+                        }
-458
+                    }
-459
+    }
-460
+}

@@ -1480,1477 +1540,1536 @@

↥ Expand context

-1477
+}
-1478
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1487
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1491
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRequiredInputFuture;
-1494
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDREQUIRED,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1502
+            }
             crate::protocol_serde::shape_malformed_required::de_malformed_required_http_request(
                 request,
-1505
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1514
+                )
             },
         );

↧ Expand context

         MalformedRequiredInputFuture {
             inner: Box::pin(fut),
-1519
+        }
-1520
+    }
-1521
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRequiredOutput
-1526
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_required::ser_malformed_required_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1535
+            }
-1536
+        }

@@ -1755,1751 +1815,1810 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1752
+    }
-1753
+}
-1754
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRangeOverrideInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1763
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1767
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRangeOverrideInputFuture;
-1770

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDRANGEOVERRIDE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1778
+            }
             crate::protocol_serde::shape_malformed_range_override::de_malformed_range_override_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1788
+                )
             },
         );

↧ Expand context

         MalformedRangeOverrideInputFuture {
             inner: Box::pin(fut),
-1793
+        }
-1794
+    }
-1795
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRangeOverrideOutput
-1800
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_range_override::ser_malformed_range_override_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1807
+                        }
-1808
+                    }
-1809
+    }
-1810
+}

@@ -2924,2919 +2984,2978 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2920
+    }
-2921
+}
-2922
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRangeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2931
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2935
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRangeInputFuture;
-2938

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDRANGE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2946
+            }
             crate::protocol_serde::shape_malformed_range::de_malformed_range_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2956
+                )
             },
         );

↧ Expand context

         MalformedRangeInputFuture {
             inner: Box::pin(fut),
-2961
+        }
-2962
+    }
-2963
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRangeOutput
-2968
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_range::ser_malformed_range_http_response(self)
-2971
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2976
+            }
-2977
+        }
-2978
+    }

@@ -4096,4090 +4156,4149 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-4091
+    }
-4092
+}
-4093
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedPatternOverrideInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4102
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4106
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedPatternOverrideInputFuture;
-4109

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDPATTERNOVERRIDE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4117
+            }
             crate::protocol_serde::shape_malformed_pattern_override::de_malformed_pattern_override_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-4127
+                )
             },
         );

↧ Expand context

         MalformedPatternOverrideInputFuture {
             inner: Box::pin(fut),
-4132
+        }
-4133
+    }
-4134
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedPatternOverrideOutput
-4139
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_pattern_override::ser_malformed_pattern_override_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4146
+                        }
-4147
+                    }
-4148
+    }
-4149
+}

@@ -4733,4726 +4793,4785 @@

↥ Expand context

-4726
+}
-4727
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedPatternInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4736
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4740
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedPatternInputFuture;
-4743
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDPATTERN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4751
+            }
             crate::protocol_serde::shape_malformed_pattern::de_malformed_pattern_http_request(
                 request,
-4754
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-4763
+                )
             },
         );

↧ Expand context

         MalformedPatternInputFuture {
             inner: Box::pin(fut),
-4768
+        }
-4769
+    }
-4770
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedPatternOutput
-4775
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_pattern::ser_malformed_pattern_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4784
+            }
-4785
+        }

@@ -5477,5469 +5537,5528 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-5470
+    }
-5471
+}
-5472
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLengthQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-5481
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-5485
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLengthQueryStringInputFuture;
-5488

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLENGTHQUERYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5496
+            }
             crate::protocol_serde::shape_malformed_length_query_string::de_malformed_length_query_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-5506
+                )
             },
         );

↧ Expand context

         MalformedLengthQueryStringInputFuture {
             inner: Box::pin(fut),
-5511
+        }
-5512
+    }
-5513
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLengthQueryStringOutput
-5518
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_length_query_string::ser_malformed_length_query_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5525
+                        }
-5526
+                    }
-5527
+    }
-5528
+}

@@ -5636,5627 +5696,5686 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-5628
+    }
-5629
+}
-5630
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLengthOverrideInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-5639
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-5643
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLengthOverrideInputFuture;
-5646

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLENGTHOVERRIDE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5654
+            }
             crate::protocol_serde::shape_malformed_length_override::de_malformed_length_override_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-5664
+                )
             },
         );

↧ Expand context

         MalformedLengthOverrideInputFuture {
             inner: Box::pin(fut),
-5669
+        }
-5670
+    }
-5671
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLengthOverrideOutput
-5676
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_length_override::ser_malformed_length_override_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5683
+                        }
-5684
+                    }
-5685
+    }
-5686
+}

@@ -6318,6308 +6378,6367 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-6309
+    }
-6310
+}
-6311
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLengthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-6320
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-6324
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLengthInputFuture;
-6327

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLENGTH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6335
+            }
             crate::protocol_serde::shape_malformed_length::de_malformed_length_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-6345
+                )
             },
         );

↧ Expand context

         MalformedLengthInputFuture {
             inner: Box::pin(fut),
-6350
+        }
-6351
+    }
-6352
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLengthOutput
-6357
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_length::ser_malformed_length_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6366
+            }
-6367
+        }

@@ -7317,7306 +7377,7365 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-7307
+    }
-7308
+}
-7309
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedEnumInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-7318
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-7322
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedEnumInputFuture;
-7325

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDENUM,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7333
+            }
             crate::protocol_serde::shape_malformed_enum::de_malformed_enum_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-7343
+                )
             },
         );

↧ Expand context

         MalformedEnumInputFuture {
             inner: Box::pin(fut),
-7348
+        }
-7349
+    }
-7350
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedEnumOutput
-7355
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_enum::ser_malformed_enum_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7362
+            }
-7363
+        }
-7364
+    }
-7365
+}

Pages: 1 2