Server Test Python

Server Test Python

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/Cargo.toml

@@ -1,1 +65,65 @@

↥ Expand context

 [package]
 name = "rest_json"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "aws.protocols#restJson1"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-http-server-python]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server-python"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-legacy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-legacy-http"
 [dependencies.aws-smithy-legacy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-legacy-http-server"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["http-02x"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-0-4-x"]
 [dependencies.form_urlencoded]
 version = "1"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.mime]
 version = "0.3"
 [dependencies.nom]
 version = "7"
 [dependencies.parking_lot]
 version = "0.12"
 [dependencies.percent-encoding]
 version = "2.0.0"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.pyo3]
 version = "0.20"
 [dependencies.pyo3-asyncio]
 version = "0.20"
 features = ["attributes", "tokio-runtime"]
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.hyper]
 version = "0.14.12"
 [dev-dependencies.tokio]
 version = "1.23.1"
 [features]
 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
 aws-lambda = ["aws-smithy-legacy-http-server/aws-lambda"]
 request-id = ["aws-smithy-legacy-http-server/request-id"]
 rt-tokio = ["aws-smithy-types/http-body-1-x", "aws-smithy-types/rt-tokio"]
 extension-module = ["pyo3/extension-module"]
 default = ["request-id", "rt-tokio", "extension-module"]
 [lib]
 name = "rest_json"
 crate-type = ["cdylib"]
-64
-65

tmp-codegen-diff/codegen-server-test-python/rest_json/rust-server-codegen-python/python/rest_json/middleware/init.pyi

@@ -1,1 +38,38 @@

 import typing
-2
 class MiddlewareException(Exception):
     """
     Exception that can be thrown from a Python middleware.
-6
     It allows to specify a message and HTTP status code and implementing protocol specific capabilities
     to build a [aws_smithy_http_server::response::Response] from it.
     to build a [aws_smithy_legacy_http_server::response::Response] from it.
     """
-10
     message: str
-12
     status_code: int
-14
     def __init__(self, message: str, status_code: typing.Optional[int] = ...) -> None:
         ...
-17
-18

↧ Expand context

 class Request:
     """
     Python-compatible [Request] object.
     """
-23
     body: typing.Awaitable[bytes]
     """
     Return the HTTP body of this request.
     Note that this is a costly operation because the whole request body is cloned.
     """
-29
     headers: typing.MutableMapping[str, str]
     """
     Return the HTTP headers of this request.
     """
-34
     method: str
     """
     Return the HTTP method of this request.
     """

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

@@ -7646,7646 +7706,7706 @@

↥ Expand context

         /// `top_level` was not provided but it is required when building `OperationWithNestedStructureInput`.
         MissingTopLevel,
         /// Constraint violation occurred building member `top_level` when building `OperationWithNestedStructureInput`.
         #[doc(hidden)]
         TopLevel(crate::model::top_level_internal::ConstraintViolation),
-7651
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTopLevel => write!(f, "`top_level` was not provided but it is required when building `OperationWithNestedStructureInput`"),
                 ConstraintViolation::TopLevel(_) => write!(f, "constraint violation occurred building member `top_level` when building `OperationWithNestedStructureInput`"),
-7657
+            }
-7658
+        }
-7659
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {

             match self {
             ConstraintViolation::MissingTopLevel => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/topLevel' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/topLevel",
                                             },
             ConstraintViolation::TopLevel(inner) => inner.as_validation_exception_field(path + "/topLevel"),
-7672
+        }
-7673
+        }
-7674
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-7677
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-7691
+                            )
-7692
+        }
-7693
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::OperationWithNestedStructureInput>
-7696
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-7699
+        }
-7700
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::OperationWithNestedStructureInput {
         type Error = ConstraintViolation;
-7703
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-7706
+        }

@@ -7809,7809 +7869,7869 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `defaults` when building `OperationWithDefaultsInput`.
         #[doc(hidden)]
         Defaults(crate::model::defaults_internal::ConstraintViolation),
-7817
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Defaults(_) => write!(f, "constraint violation occurred building member `defaults` when building `OperationWithDefaultsInput`"),
-7822
+            }
-7823
+        }
-7824
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Defaults(inner) => {
                     inner.as_validation_exception_field(path + "/defaults")
-7834
+                }
-7835
+            }
-7836
+        }
-7837
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-7840
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-7854
+                            )
-7855
+        }
-7856
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::OperationWithDefaultsInput>
-7859
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-7862
+        }
-7863
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::OperationWithDefaultsInput {
         type Error = ConstraintViolation;
-7866
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-7869
+        }

@@ -9144,9144 +9204,9204 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampBodyHttpDateInput`.
         MissingTimestamp,
-9151
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampBodyHttpDateInput`"),
-9156
+            }
-9157
+        }
-9158
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-9170
+        }
-9171
+        }
-9172
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-9175
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-9189
+                            )
-9190
+        }
-9191
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampBodyHttpDateInput>
-9194
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-9197
+        }
-9198
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampBodyHttpDateInput {
         type Error = ConstraintViolation;
-9201
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-9204
+        }

@@ -9308,9308 +9368,9368 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampBodyDateTimeInput`.
         MissingTimestamp,
-9315
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampBodyDateTimeInput`"),
-9320
+            }
-9321
+        }
-9322
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-9334
+        }
-9335
+        }
-9336
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-9339
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-9353
+                            )
-9354
+        }
-9355
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampBodyDateTimeInput>
-9358
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-9361
+        }
-9362
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampBodyDateTimeInput {
         type Error = ConstraintViolation;
-9365
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-9368
+        }

@@ -9472,9472 +9532,9532 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampBodyDefaultInput`.
         MissingTimestamp,
-9479
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampBodyDefaultInput`"),
-9484
+            }
-9485
+        }
-9486
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-9498
+        }
-9499
+        }
-9500
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-9503
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-9517
+                            )
-9518
+        }
-9519
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampBodyDefaultInput>
-9522
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-9525
+        }
-9526
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampBodyDefaultInput {
         type Error = ConstraintViolation;
-9529
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-9532
+        }

@@ -9632,9632 +9692,9692 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampHeaderEpochInput`.
         MissingTimestamp,
-9639
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampHeaderEpochInput`"),
-9644
+            }
-9645
+        }
-9646
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-9658
+        }
-9659
+        }
-9660
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-9663
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-9677
+                            )
-9678
+        }
-9679
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampHeaderEpochInput>
-9682
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-9685
+        }
-9686
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampHeaderEpochInput {
         type Error = ConstraintViolation;
-9689
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-9692
+        }

@@ -9792,9792 +9852,9852 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampHeaderDateTimeInput`.
         MissingTimestamp,
-9799
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampHeaderDateTimeInput`"),
-9804
+            }
-9805
+        }
-9806
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-9818
+        }
-9819
+        }
-9820
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-9823
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-9837
+                            )
-9838
+        }
-9839
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<
             crate::input::MalformedTimestampHeaderDateTimeInput,
-9843
+        >
-9844
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-9847
+        }
-9848
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampHeaderDateTimeInput {
         type Error = ConstraintViolation;
-9851
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

@@ -9958,9958 +10018,10018 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampHeaderDefaultInput`.
         MissingTimestamp,
-9965
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampHeaderDefaultInput`"),
-9970
+            }
-9971
+        }
-9972
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-9984
+        }
-9985
+        }
-9986
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-9989
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10003
+                            )
-10004
+        }
-10005
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampHeaderDefaultInput>
-10008
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10011
+        }
-10012
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampHeaderDefaultInput {
         type Error = ConstraintViolation;
-10015
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10018
+        }

@@ -10122,10122 +10182,10182 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampQueryEpochInput`.
         MissingTimestamp,
-10129
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampQueryEpochInput`"),
-10134
+            }
-10135
+        }
-10136
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-10148
+        }
-10149
+        }
-10150
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-10153
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10167
+                            )
-10168
+        }
-10169
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampQueryEpochInput>
-10172
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10175
+        }
-10176
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampQueryEpochInput {
         type Error = ConstraintViolation;
-10179
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10182
+        }

@@ -10282,10282 +10342,10342 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampQueryHttpDateInput`.
         MissingTimestamp,
-10289
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampQueryHttpDateInput`"),
-10294
+            }
-10295
+        }
-10296
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-10308
+        }
-10309
+        }
-10310
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-10313
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10327
+                            )
-10328
+        }
-10329
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampQueryHttpDateInput>
-10332
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10335
+        }
-10336
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampQueryHttpDateInput {
         type Error = ConstraintViolation;
-10339
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10342
+        }

@@ -10446,10446 +10506,10506 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampQueryDefaultInput`.
         MissingTimestamp,
-10453
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampQueryDefaultInput`"),
-10458
+            }
-10459
+        }
-10460
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-10472
+        }
-10473
+        }
-10474
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-10477
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10491
+                            )
-10492
+        }
-10493
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampQueryDefaultInput>
-10496
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10499
+        }
-10500
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampQueryDefaultInput {
         type Error = ConstraintViolation;
-10503
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10506
+        }

@@ -10610,10610 +10670,10670 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampPathEpochInput`.
         MissingTimestamp,
-10617
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampPathEpochInput`"),
-10622
+            }
-10623
+        }
-10624
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-10636
+        }
-10637
+        }
-10638
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-10641
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10655
+                            )
-10656
+        }
-10657
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampPathEpochInput>
-10660
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10663
+        }
-10664
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampPathEpochInput {
         type Error = ConstraintViolation;
-10667
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10670
+        }

@@ -10770,10770 +10830,10830 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampPathHttpDateInput`.
         MissingTimestamp,
-10777
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampPathHttpDateInput`"),
-10782
+            }
-10783
+        }
-10784
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-10796
+        }
-10797
+        }
-10798
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-10801
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10815
+                            )
-10816
+        }
-10817
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampPathHttpDateInput>
-10820
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10823
+        }
-10824
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampPathHttpDateInput {
         type Error = ConstraintViolation;
-10827
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10830
+        }

@@ -10934,10934 +10994,10994 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `timestamp` was not provided but it is required when building `MalformedTimestampPathDefaultInput`.
         MissingTimestamp,
-10941
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingTimestamp => write!(f, "`timestamp` was not provided but it is required when building `MalformedTimestampPathDefaultInput`"),
-10946
+            }
-10947
+        }
-10948
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-10960
+        }
-10961
+        }
-10962
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-10965
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-10979
+                            )
-10980
+        }
-10981
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedTimestampPathDefaultInput>
-10984
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-10987
+        }
-10988
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedTimestampPathDefaultInput {
         type Error = ConstraintViolation;
-10991
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-10994
+        }

@@ -11153,11153 +11213,11213 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `double_in_path` was not provided but it is required when building `MalformedDoubleInput`.
         MissingDoubleInPath,
-11160
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingDoubleInPath => write!(f, "`double_in_path` was not provided but it is required when building `MalformedDoubleInput`"),
-11165
+            }
-11166
+        }
-11167
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingDoubleInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/doubleInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/doubleInPath",
                                             },
-11179
+        }
-11180
+        }
-11181
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-11184
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-11198
+                            )
-11199
+        }
-11200
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedDoubleInput>
-11203
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-11206
+        }
-11207
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedDoubleInput {
         type Error = ConstraintViolation;
-11210
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-11213
+        }

@@ -11352,11352 +11412,11412 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `float_in_path` was not provided but it is required when building `MalformedFloatInput`.
         MissingFloatInPath,
-11359
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingFloatInPath => write!(f, "`float_in_path` was not provided but it is required when building `MalformedFloatInput`"),
-11364
+            }
-11365
+        }
-11366
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingFloatInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/floatInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/floatInPath",
                                             },
-11378
+        }
-11379
+        }
-11380
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-11383
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-11397
+                            )
-11398
+        }
-11399
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedFloatInput>
-11402
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-11405
+        }
-11406
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedFloatInput {
         type Error = ConstraintViolation;
-11409
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-11412
+        }

@@ -11551,11551 +11611,11611 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `long_in_path` was not provided but it is required when building `MalformedLongInput`.
         MissingLongInPath,
-11558
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingLongInPath => write!(f, "`long_in_path` was not provided but it is required when building `MalformedLongInput`"),
-11563
+            }
-11564
+        }
-11565
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingLongInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/longInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/longInPath",
                                             },
-11577
+        }
-11578
+        }
-11579
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-11582
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-11596
+                            )
-11597
+        }
-11598
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedLongInput>
-11601
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-11604
+        }
-11605
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedLongInput {
         type Error = ConstraintViolation;
-11608
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-11611
+        }

@@ -11750,11750 +11810,11810 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `short_in_path` was not provided but it is required when building `MalformedShortInput`.
         MissingShortInPath,
-11757
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingShortInPath => write!(f, "`short_in_path` was not provided but it is required when building `MalformedShortInput`"),
-11762
+            }
-11763
+        }
-11764
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingShortInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/shortInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/shortInPath",
                                             },
-11776
+        }
-11777
+        }
-11778
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-11781
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-11795
+                            )
-11796
+        }
-11797
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedShortInput>
-11800
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-11803
+        }
-11804
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedShortInput {
         type Error = ConstraintViolation;
-11807
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-11810
+        }

@@ -11949,11949 +12009,12009 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `byte_in_path` was not provided but it is required when building `MalformedByteInput`.
         MissingByteInPath,
-11956
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingByteInPath => write!(f, "`byte_in_path` was not provided but it is required when building `MalformedByteInput`"),
-11961
+            }
-11962
+        }
-11963
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingByteInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/byteInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/byteInPath",
                                             },
-11975
+        }
-11976
+        }
-11977
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-11980
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-11994
+                            )
-11995
+        }
-11996
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedByteInput>
-11999
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-12002
+        }
-12003
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedByteInput {
         type Error = ConstraintViolation;
-12006
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-12009
+        }

@@ -12352,12352 +12412,12412 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `boolean_in_path` was not provided but it is required when building `MalformedBooleanInput`.
         MissingBooleanInPath,
-12359
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingBooleanInPath => write!(f, "`boolean_in_path` was not provided but it is required when building `MalformedBooleanInput`"),
-12364
+            }
-12365
+        }
-12366
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingBooleanInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/booleanInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/booleanInPath",
                                             },
-12378
+        }
-12379
+        }
-12380
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-12383
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-12397
+                            )
-12398
+        }
-12399
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedBooleanInput>
-12402
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-12405
+        }
-12406
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedBooleanInput {
         type Error = ConstraintViolation;
-12409
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-12412
+        }

@@ -12613,12613 +12673,12673 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `integer_in_path` was not provided but it is required when building `MalformedIntegerInput`.
         MissingIntegerInPath,
-12620
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingIntegerInPath => write!(f, "`integer_in_path` was not provided but it is required when building `MalformedIntegerInput`"),
-12625
+            }
-12626
+        }
-12627
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,

         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingIntegerInPath => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/integerInPath' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/integerInPath",
                                             },
-12639
+        }
-12640
+        }
-12641
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-12644
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-12658
+                            )
-12659
+        }
-12660
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::MalformedIntegerInput>
-12663
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-12666
+        }
-12667
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::MalformedIntegerInput {
         type Error = ConstraintViolation;
-12670
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-12673
+        }

@@ -12996,12996 +13056,13056 @@

↥ Expand context

     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `label` was not provided but it is required when building `EndpointWithHostLabelOperationInput`.
         MissingLabel,
-13000
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingLabel => write!(f, "`label` was not provided but it is required when building `EndpointWithHostLabelOperationInput`"),
-13005
+            }
-13006
+        }
-13007
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::MissingLabel => crate::model::ValidationExceptionField {

                     message: format!(
                         "Value at '{}/label' failed to satisfy constraint: Member must not be null",
                         path
                     ),
                     path: path + "/label",
                 },
-13022
+            }
-13023
+        }
-13024
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-13027
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-13041
+                            )
-13042
+        }
-13043
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::EndpointWithHostLabelOperationInput>
-13046
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-13049
+        }
-13050
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::EndpointWithHostLabelOperationInput {
         type Error = ConstraintViolation;
-13053
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-13056
+        }

@@ -13320,13320 +13380,13380 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `contents` when building `JsonUnionsInput`.
         #[doc(hidden)]
         Contents(crate::model::my_union_internal::ConstraintViolation),
-13328
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Contents(_) => write!(f, "constraint violation occurred building member `contents` when building `JsonUnionsInput`"),
-13333
+            }
-13334
+        }
-13335
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Contents(inner) => {
                     inner.as_validation_exception_field(path + "/contents")
-13345
+                }
-13346
+            }
-13347
+        }
-13348
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-13351
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-13365
+                            )
-13366
+        }
-13367
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonUnionsInput>
-13370
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-13373
+        }
-13374
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonUnionsInput {
         type Error = ConstraintViolation;
-13377
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-13380
+        }

@@ -13766,13766 +13826,13826 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `sparse_set_map` when building `SparseJsonMapsInput`.
         #[doc(hidden)]
         SparseSetMap(crate::model::sparse_set_map_internal::ConstraintViolation),
-13774
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::SparseSetMap(_) => write!(f, "constraint violation occurred building member `sparse_set_map` when building `SparseJsonMapsInput`"),
-13779
+            }
-13780
+        }
-13781
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::SparseSetMap(inner) => {
                     inner.as_validation_exception_field(path + "/sparseSetMap")
-13791
+                }
-13792
+            }
-13793
+        }
-13794
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-13797
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-13811
+                            )
-13812
+        }
-13813
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::SparseJsonMapsInput>
-13816
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-13819
+        }
-13820
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::SparseJsonMapsInput {
         type Error = ConstraintViolation;
-13823
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-13826
+        }

@@ -14068,14068 +14128,14128 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `dense_set_map` when building `JsonMapsInput`.
         #[doc(hidden)]
         DenseSetMap(crate::model::dense_set_map_internal::ConstraintViolation),
-14076
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::DenseSetMap(_) => write!(f, "constraint violation occurred building member `dense_set_map` when building `JsonMapsInput`"),
-14081
+            }
-14082
+        }
-14083
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::DenseSetMap(inner) => {
                     inner.as_validation_exception_field(path + "/denseSetMap")
-14093
+                }
-14094
+            }
-14095
+        }
-14096
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-14099
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-14113
+                            )
-14114
+        }
-14115
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonMapsInput>
-14118
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-14121
+        }
-14122
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonMapsInput {
         type Error = ConstraintViolation;
-14125
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-14128
+        }

@@ -14438,14438 +14498,14498 @@

↥ Expand context

         StringSet(crate::model::string_set_internal::ConstraintViolation),
         /// Constraint violation occurred building member `enum_list` when building `JsonListsInput`.
         #[doc(hidden)]
         EnumList(crate::model::foo_enum_list_internal::ConstraintViolation),
-14442
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::StringSet(_) => write!(f, "constraint violation occurred building member `string_set` when building `JsonListsInput`"),
                 ConstraintViolation::EnumList(_) => write!(f, "constraint violation occurred building member `enum_list` when building `JsonListsInput`"),
-14448
+            }
-14449
+        }
-14450
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {

                 ConstraintViolation::StringSet(inner) => {
                     inner.as_validation_exception_field(path + "/stringSet")
-14460
+                }
                 ConstraintViolation::EnumList(inner) => {
                     inner.as_validation_exception_field(path + "/enumList")
-14463
+                }
-14464
+            }
-14465
+        }
-14466
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-14469
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-14483
+                            )
-14484
+        }
-14485
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonListsInput>
-14488
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-14491
+        }
-14492
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonListsInput {
         type Error = ConstraintViolation;
-14495
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-14498
+        }

@@ -14832,14832 +14892,14892 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `integer_enum_set` when building `JsonIntEnumsInput`.
         #[doc(hidden)]
         IntegerEnumSet(crate::model::integer_enum_set_internal::ConstraintViolation),
-14840
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::IntegerEnumSet(_) => write!(f, "constraint violation occurred building member `integer_enum_set` when building `JsonIntEnumsInput`"),
-14845
+            }
-14846
+        }
-14847
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::IntegerEnumSet(inner) => {
                     inner.as_validation_exception_field(path + "/integerEnumSet")
-14857
+                }
-14858
+            }
-14859
+        }
-14860
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-14863
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-14877
+                            )
-14878
+        }
-14879
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonIntEnumsInput>
-14882
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-14885
+        }
-14886
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonIntEnumsInput {
         type Error = ConstraintViolation;
-14889
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-14892
+        }

@@ -15104,15104 +15164,15164 @@

↥ Expand context

-15104
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::FooEnum1(inner) => {
                     inner.as_validation_exception_field(path + "/fooEnum1")
-15114
+                }
                 ConstraintViolation::FooEnum2(inner) => {
                     inner.as_validation_exception_field(path + "/fooEnum2")
-15117
+                }
                 ConstraintViolation::FooEnum3(inner) => {
                     inner.as_validation_exception_field(path + "/fooEnum3")
-15120
+                }
                 ConstraintViolation::FooEnumList(inner) => {
                     inner.as_validation_exception_field(path + "/fooEnumList")
-15123
+                }

                 ConstraintViolation::FooEnumSet(inner) => {
                     inner.as_validation_exception_field(path + "/fooEnumSet")
-15126
+                }
                 ConstraintViolation::FooEnumMap(inner) => {
                     inner.as_validation_exception_field(path + "/fooEnumMap")
-15129
+                }
-15130
+            }
-15131
+        }
-15132
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-15135
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-15149
+                            )
-15150
+        }
-15151
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::JsonEnumsInput>
-15154
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-15157
+        }
-15158
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::JsonEnumsInput {
         type Error = ConstraintViolation;
-15161
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-15164
+        }

@@ -16389,16389 +16449,16449 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `payload` when building `HttpEnumPayloadInput`.
         #[doc(hidden)]
         Payload(crate::model::string_enum_internal::ConstraintViolation),
-16397
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::Payload(_) => write!(f, "constraint violation occurred building member `payload` when building `HttpEnumPayloadInput`"),
-16402
+            }
-16403
+        }
-16404
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Payload(inner) => {
                     inner.as_validation_exception_field(path + "/payload")
-16414
+                }
-16415
+            }
-16416
+        }
-16417
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-16420
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-16434
+                            )
-16435
+        }
-16436
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::HttpEnumPayloadInput>
-16439
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-16442
+        }
-16443
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpEnumPayloadInput {
         type Error = ConstraintViolation;
-16446
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-16449
+        }

@@ -17259,17259 +17319,17319 @@

↥ Expand context

     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     #[non_exhaustive]
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `query_enum_list` when building `OmitsSerializingEmptyListsInput`.
         #[doc(hidden)]
         QueryEnumList(crate::model::foo_enum_list_internal::ConstraintViolation),
-17267
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::QueryEnumList(_) => write!(f, "constraint violation occurred building member `query_enum_list` when building `OmitsSerializingEmptyListsInput`"),
-17272
+            }
-17273
+        }
-17274
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,

             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::QueryEnumList(inner) => {
                     inner.as_validation_exception_field(path + "/queryEnumList")
-17284
+                }
-17285
+            }
-17286
+        }
-17287
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-17290
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-17304
+                            )
-17305
+        }
-17306
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::OmitsSerializingEmptyListsInput>
-17309
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-17312
+        }
-17313
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::OmitsSerializingEmptyListsInput {
         type Error = ConstraintViolation;
-17316
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-17319
+        }

@@ -17756,17756 +17816,17816 @@

↥ Expand context

     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `hello` was not provided but it is required when building `ConstantQueryStringInput`.
         MissingHello,
-17760
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingHello => write!(f, "`hello` was not provided but it is required when building `ConstantQueryStringInput`"),
-17765
+            }
-17766
+        }
-17767
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::MissingHello => crate::model::ValidationExceptionField {

                     message: format!(
                         "Value at '{}/hello' failed to satisfy constraint: Member must not be null",
                         path
                     ),
                     path: path + "/hello",
                 },
-17782
+            }
-17783
+        }
-17784
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-17787
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-17801
+                            )
-17802
+        }
-17803
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::ConstantQueryStringInput>
-17806
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-17809
+        }
-17810
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::ConstantQueryStringInput {
         type Error = ConstraintViolation;
-17813
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-17816
+        }

@@ -17924,17924 +17984,17984 @@

↥ Expand context

                 ConstraintViolation::QueryStringSet(_) => write!(f, "constraint violation occurred building member `query_string_set` when building `AllQueryStringTypesInput`"),
                 ConstraintViolation::QueryIntegerSet(_) => write!(f, "constraint violation occurred building member `query_integer_set` when building `AllQueryStringTypesInput`"),
                 ConstraintViolation::QueryEnum(_) => write!(f, "constraint violation occurred building member `query_enum` when building `AllQueryStringTypesInput`"),
                 ConstraintViolation::QueryEnumList(_) => write!(f, "constraint violation occurred building member `query_enum_list` when building `AllQueryStringTypesInput`"),
-17928
+            }
-17929
+        }
-17930
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::QueryStringSet(inner) => {
                     inner.as_validation_exception_field(path + "/queryStringSet")
-17940
+                }
                 ConstraintViolation::QueryIntegerSet(inner) => {
                     inner.as_validation_exception_field(path + "/queryIntegerSet")
-17943
+                }

                 ConstraintViolation::QueryEnum(inner) => {
                     inner.as_validation_exception_field(path + "/queryEnum")
-17946
+                }
                 ConstraintViolation::QueryEnumList(inner) => {
                     inner.as_validation_exception_field(path + "/queryEnumList")
-17949
+                }
-17950
+            }
-17951
+        }
-17952
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-17955
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-17969
+                            )
-17970
+        }
-17971
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::AllQueryStringTypesInput>
-17974
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-17977
+        }
-17978
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::AllQueryStringTypesInput {
         type Error = ConstraintViolation;
-17981
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-17984
+        }

@@ -18518,18518 +18578,18578 @@

↥ Expand context

     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `str` was not provided but it is required when building `HttpRequestWithRegexLiteralInput`.
         MissingStr,
-18522
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingStr => write!(f, "`str` was not provided but it is required when building `HttpRequestWithRegexLiteralInput`"),
-18527
+            }
-18528
+        }
-18529
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::MissingStr => crate::model::ValidationExceptionField {

                     message: format!(
                         "Value at '{}/str' failed to satisfy constraint: Member must not be null",
                         path
                     ),
                     path: path + "/str",
                 },
-18544
+            }
-18545
+        }
-18546
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-18549
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-18563
+                            )
-18564
+        }
-18565
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::HttpRequestWithRegexLiteralInput>
-18568
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-18571
+        }
-18572
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpRequestWithRegexLiteralInput {
         type Error = ConstraintViolation;
-18575
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-18578
+        }

@@ -18676,18676 +18736,18736 @@

↥ Expand context

         /// `double` was not provided but it is required when building `HttpRequestWithFloatLabelsInput`.
         MissingDouble,
-18678
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingFloat => write!(f, "`float` was not provided but it is required when building `HttpRequestWithFloatLabelsInput`"),
                 ConstraintViolation::MissingDouble => write!(f, "`double` was not provided but it is required when building `HttpRequestWithFloatLabelsInput`"),
-18684
+            }
-18685
+        }
-18686
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingFloat => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/float' failed to satisfy constraint: Member must not be null", path),

                                                 path: path + "/float",
                                             },
             ConstraintViolation::MissingDouble => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/double' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/double",
                                             },
-18702
+        }
-18703
+        }
-18704
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-18707
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-18721
+                            )
-18722
+        }
-18723
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::HttpRequestWithFloatLabelsInput>
-18726
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-18729
+        }
-18730
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpRequestWithFloatLabelsInput {
         type Error = ConstraintViolation;
-18733
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-18736
+        }

@@ -18855,18855 +18915,18915 @@

↥ Expand context

                 ConstraintViolation::MissingFoo => write!(f, "`foo` was not provided but it is required when building `HttpRequestWithGreedyLabelInPathInput`"),
                 ConstraintViolation::MissingBaz => write!(f, "`baz` was not provided but it is required when building `HttpRequestWithGreedyLabelInPathInput`"),
-18857
+            }
-18858
+        }
-18859
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::MissingFoo => crate::model::ValidationExceptionField {
                     message: format!(
                         "Value at '{}/foo' failed to satisfy constraint: Member must not be null",
                         path
                     ),
                     path: path + "/foo",
                 },
                 ConstraintViolation::MissingBaz => crate::model::ValidationExceptionField {

                     message: format!(
                         "Value at '{}/baz' failed to satisfy constraint: Member must not be null",
                         path
                     ),
                     path: path + "/baz",
                 },
-18881
+            }
-18882
+        }
-18883
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-18886
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-18900
+                            )
-18901
+        }
-18902
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<
             crate::input::HttpRequestWithGreedyLabelInPathInput,
-18906
+        >
-18907
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-18910
+        }
-18911
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpRequestWithGreedyLabelInPathInput {
         type Error = ConstraintViolation;
-18914
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {

@@ -19075,19075 +19135,19135 @@

↥ Expand context

                                                 path: path + "/memberEpochSeconds",
                                             },
             ConstraintViolation::MissingMemberHttpDate => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/memberHttpDate' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/memberHttpDate",
                                             },
             ConstraintViolation::MissingMemberDateTime => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/memberDateTime' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/memberDateTime",
                                             },
             ConstraintViolation::MissingDefaultFormat => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/defaultFormat' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/defaultFormat",
                                             },
             ConstraintViolation::MissingTargetEpochSeconds => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/targetEpochSeconds' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/targetEpochSeconds",
                                             },
             ConstraintViolation::MissingTargetHttpDate => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/targetHttpDate' failed to satisfy constraint: Member must not be null", path),

                                                 path: path + "/targetHttpDate",
                                             },
             ConstraintViolation::MissingTargetDateTime => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/targetDateTime' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/targetDateTime",
                                             },
-19101
+        }
-19102
+        }
-19103
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-19106
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-19120
+                            )
-19121
+        }
-19122
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<
             crate::input::HttpRequestWithLabelsAndTimestampFormatInput,
-19126
+        >
-19127
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-19130
+        }
-19131
+    }
     impl ::std::convert::TryFrom<Builder>
         for crate::input::HttpRequestWithLabelsAndTimestampFormatInput
-19134
+    {
         type Error = ConstraintViolation;

@@ -19469,19469 +19529,19529 @@

↥ Expand context

                                                 path: path + "/short",
                                             },
             ConstraintViolation::MissingInteger => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/integer' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/integer",
                                             },
             ConstraintViolation::MissingLong => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/long' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/long",
                                             },
             ConstraintViolation::MissingFloat => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/float' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/float",
                                             },
             ConstraintViolation::MissingDouble => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/double' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/double",
                                             },
             ConstraintViolation::MissingBoolean => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/boolean' failed to satisfy constraint: Member must not be null", path),

                                                 path: path + "/boolean",
                                             },
             ConstraintViolation::MissingTimestamp => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/timestamp' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/timestamp",
                                             },
-19495
+        }
-19496
+        }
-19497
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-19500
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-19514
+                            )
-19515
+        }
-19516
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::HttpRequestWithLabelsInput>
-19519
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-19522
+        }
-19523
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::HttpRequestWithLabelsInput {
         type Error = ConstraintViolation;
-19526
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-19529
+        }

@@ -20245,20245 +20305,20305 @@

↥ Expand context

-20245
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::HeaderStringSet(_) => write!(f, "constraint violation occurred building member `header_string_set` when building `InputAndOutputWithHeadersInput`"),
                 ConstraintViolation::HeaderEnum(_) => write!(f, "constraint violation occurred building member `header_enum` when building `InputAndOutputWithHeadersInput`"),
                 ConstraintViolation::HeaderEnumList(_) => write!(f, "constraint violation occurred building member `header_enum_list` when building `InputAndOutputWithHeadersInput`"),
-20252
+            }
-20253
+        }
-20254
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::HeaderStringSet(inner) => {
                     inner.as_validation_exception_field(path + "/headerStringSet")
-20264
+                }

                 ConstraintViolation::HeaderEnum(inner) => {
                     inner.as_validation_exception_field(path + "/headerEnum")
-20267
+                }
                 ConstraintViolation::HeaderEnumList(inner) => {
                     inner.as_validation_exception_field(path + "/headerEnumList")
-20270
+                }
-20271
+            }
-20272
+        }
-20273
+    }
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
         for ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection
-20276
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),

↧ Expand context

             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-20290
+                            )
-20291
+        }
-20292
+    }
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::InputAndOutputWithHeadersInput>
-20295
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-20298
+        }
-20299
+    }
     impl ::std::convert::TryFrom<Builder> for crate::input::InputAndOutputWithHeadersInput {
         type Error = ConstraintViolation;
-20302
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-20305
+        }

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

@@ -29,29 +128,129 @@

↥ Expand context

 //! The primary entrypoint is [`RestJson`]: it satisfies the [`Service<http::Request, Response = http::Response>`](::tower::Service)
 //! trait and therefore can be handed to a [`hyper` server](https://github.com/hyperium/hyper) via [`RestJson::into_make_service`]
 //! or used in AWS Lambda
 #![cfg_attr(
     feature = "aws-lambda",
     doc = " via [`LambdaHandler`](crate::server::routing::LambdaHandler)."
 )]
 #![cfg_attr(
     not(feature = "aws-lambda"),
     doc = " by enabling the `aws-lambda` feature flag and utilizing the `LambdaHandler`."
 )]
 //! The [`crate::input`], [`crate::output`], and [`crate::error`]
 //! modules provide the types used in each operation.
 //!
 //! ### Running on Hyper
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! # async fn dummy() {
 //! use rest_json::{RestJson, RestJsonConfig};

 //!
 //! # let app = RestJson::builder(
 //! #     RestJsonConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let server = app.into_make_service();
 //! let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!     .expect("unable to parse the server bind address and port");
 //! ::hyper::Server::bind(&bind).serve(server).await.unwrap();
 //! # }
 //!
 //! ```
 //!
 //! ### Running on Lambda
 //!
 //! ```rust,ignore
 //! use rest_json::server::routing::LambdaHandler;
 //! use rest_json::RestJson;
 //!
 //! # async fn dummy() {
 //! # let app = RestJson::builder(
 //! #     RestJsonConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let handler = LambdaHandler::new(app);
 //! lambda_http::run(handler).await.unwrap();
 //! # }
 //! ```
 //!
 //! # Building the RestJson
 //!
 //! To construct [`RestJson`] we use [`RestJsonBuilder`] returned by [`RestJson::builder`].
 //!
 //! ## Plugins
 //!
 //! The [`RestJson::builder`] method, returning [`RestJsonBuilder`],
 //! accepts a config object on which plugins can be registered.
 //! Plugins allow you to build middleware which is aware of the operation it is being applied to.
 //!
 //! ```rust,no_run
 //! # use rest_json::server::plugin::IdentityPlugin as LoggingPlugin;
 //! # use rest_json::server::plugin::IdentityPlugin as MetricsPlugin;
 //! # use ::hyper::Body;
 //! use rest_json::server::plugin::HttpPlugins;
 //! use rest_json::{RestJson, RestJsonConfig, RestJsonBuilder};
 //!
 //! let http_plugins = HttpPlugins::new()
 //!         .push(LoggingPlugin)
 //!         .push(MetricsPlugin);
 //! let config = RestJsonConfig::builder().build();
 //! let builder: RestJsonBuilder<Body, _, _, _> = RestJson::builder(config);
 //! let builder: RestJsonBuilder<::hyper::Body, _, _, _> = RestJson::builder(config);
 //! ```
 //!
 //! Check out [`crate::server::plugin`] to learn more about plugins.
 //!
 //! ## Handlers
 //!
 //! [`RestJsonBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.
 //! We call these async functions **handlers**. This is where your application business logic lives.
 //!
 //! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

↧ Expand context

 //!
 //! * A `Result<Output, Error>` if your operation has modeled errors, or
 //! * An `Output` otherwise.
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! async fn infallible_handler(input: Input) -> Output { todo!() }
 //!
 //! async fn fallible_handler(input: Input) -> Result<Output, Error> { todo!() }
 //! ```
 //!
 //! Handlers can accept up to 8 extractors:
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! # struct State;

@@ -684,685 +782,783 @@

↥ Expand context

 //!     todo!()
 //! }
 //!
 //! async fn test_payload_blob(input: input::TestPayloadBlobInput) -> Result<output::TestPayloadBlobOutput, error::TestPayloadBlobError> {
 //!     todo!()
 //! }
 //!
 //! async fn test_payload_structure(input: input::TestPayloadStructureInput) -> Result<output::TestPayloadStructureOutput, error::TestPayloadStructureError> {
 //!     todo!()
 //! }
 //!
 //! async fn test_post_no_input_no_payload(input: input::TestPostNoInputNoPayloadInput) -> Result<output::TestPostNoInputNoPayloadOutput, error::TestPostNoInputNoPayloadError> {
 //!     todo!()
 //! }
 //!
 //! async fn test_post_no_payload(input: input::TestPostNoPayloadInput) -> Result<output::TestPostNoPayloadOutput, error::TestPostNoPayloadError> {
 //!     todo!()
 //! }
 //!
 //! async fn timestamp_format_headers(input: input::TimestampFormatHeadersInput) -> Result<output::TimestampFormatHeadersOutput, error::TimestampFormatHeadersError> {

 //!     todo!()
 //! }
 //!
 //! async fn unit_input_and_output(input: input::UnitInputAndOutputInput) -> Result<output::UnitInputAndOutputOutput, error::UnitInputAndOutputError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!
 //! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve
 //! [hyper server]: https://docs.rs/hyper/0.14.26/hyper/server/index.html
 //! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html
 //! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html
 //! [operations]: https://smithy.io/2.0/spec/service-types.html#operation
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html
 pub use crate::service::{
     MissingOperationsError, RestJson, RestJsonBuilder, RestJsonConfig, RestJsonConfigBuilder,
 };
-723
 /// Contains the types that are re-exported from the `aws-smithy-http-server` crate.
 pub mod server {
     // Re-export all types from the `aws-smithy-http-server` crate.
     pub use ::aws_smithy_http_server::*;
     pub use ::aws_smithy_legacy_http_server::*;
-728
+}
-729
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-732
 /// Constrained types for constrained shapes.
 mod constrained;
-735
 /// All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-738
 /// Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-741
 /// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.
 pub mod model;
-744
 /// All operations that this crate can perform.
 pub mod operation;
-747
 /// A collection of types representing each operation defined in the service closure.
 ///
 /// The [plugin system](::aws_smithy_http_server::plugin) makes use of these
 /// The [plugin system](::aws_smithy_legacy_http_server::plugin) makes use of these
 /// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to
 /// parameterize [`Plugin`](::aws_smithy_http_server::plugin::Plugin) implementations. Their traits, such as
 /// [`OperationShape`](::aws_smithy_http_server::operation::OperationShape), can be used to provide
 /// parameterize [`Plugin`](::aws_smithy_legacy_http_server::plugin::Plugin) implementations. Their traits, such as
 /// [`OperationShape`](::aws_smithy_legacy_http_server::operation::OperationShape), can be used to provide
 /// operation specific information to the [`Layer`](::tower::Layer) being applied.
 pub mod operation_shape;
-756
 /// Output structures for operations. Documentation on these types is copied from the model.
 pub mod output;
-759
 /// Export PyO3 symbols in the shared library
 pub mod python_module_export;
-762
 /// Operation adapters that delegate to Python handlers.

↧ Expand context

 pub mod python_operation_adaptor;
-765
 /// Python server and application implementation.
 pub mod python_server_application;
-768
 mod service;
-770
 /// Data primitives referenced by other data types.
 pub mod types;
-773
 /// Unconstrained types for constrained shapes.
 mod unconstrained;
-776
 mod mimes;
-778
 pub(crate) mod protocol_serde;
-780
 /// Re-exported Python types from supporting crates.
 pub mod python_types {
     pub use ::aws_smithy_http_server_python::types::Blob;

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

@@ -1,1 +10473,10240 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OperationWithNestedStructureInput`](crate::input::OperationWithNestedStructureInput) using modelled bindings.
     pub struct OperationWithNestedStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationWithNestedStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationWithNestedStructureInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7
+    }
-8
+}
-9
 impl std::future::Future for OperationWithNestedStructureInputFuture {
     type Output = Result<
         crate::input::OperationWithNestedStructureInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-15
     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)
-22
+    }
-23
+}
-24
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OperationWithNestedStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-33
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-37
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_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(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_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
         };
         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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         OperationWithNestedStructureInputFuture {
             inner: Box::pin(fut),
-60
+        }
-61
+    }
-62
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OperationWithNestedStructureOutput
-67
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-74
+                        }
-75
+                    }
-76
+    }
-77
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OperationWithNestedStructureError
-82
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-92
+            }
-93
+        }
-94
+    }
-95
+}
-96
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OperationWithDefaultsInput`](crate::input::OperationWithDefaultsInput) using modelled bindings.
     pub struct OperationWithDefaultsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationWithDefaultsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OperationWithDefaultsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-102
+    }
-103
+}
-104
 impl std::future::Future for OperationWithDefaultsInputFuture {
     type Output = Result<
         crate::input::OperationWithDefaultsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-110
     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)
-117
+    }
-118
+}
-119
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OperationWithDefaultsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-128
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-132
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OperationWithDefaultsInputFuture;
-136
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-144
+            }
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         OperationWithDefaultsInputFuture {
             inner: Box::pin(fut),
-155
+        }
-156
+    }
-157
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OperationWithDefaultsOutput
-162
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-169
+                        }
-170
+                    }
-171
+    }
-172
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OperationWithDefaultsError
-177
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-187
+            }
-188
+        }
-189
+    }
-190
+}
-191
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput) using modelled bindings.
     pub struct ContentTypeParametersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ContentTypeParametersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ContentTypeParametersInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-197
+    }
-198
+}
-199
 impl std::future::Future for ContentTypeParametersInputFuture {
     type Output = Result<
         crate::input::ContentTypeParametersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-205
     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)
-212
+    }
-213
+}
-214
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ContentTypeParametersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-223
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-227
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ContentTypeParametersInputFuture;
-231
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-239
+            }
             crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         ContentTypeParametersInputFuture {
             inner: Box::pin(fut),
-250
+        }
-251
+    }
-252
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ContentTypeParametersOutput
-257
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-264
+                        }
-265
+                    }
-266
+    }
-267
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ContentTypeParametersError
-272
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-282
+            }
-283
+        }
-284
+    }
-285
+}
-286
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput) using modelled bindings.
     pub struct PutWithContentEncodingInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PutWithContentEncodingInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PutWithContentEncodingInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-292
+    }
-293
+}
-294
 impl std::future::Future for PutWithContentEncodingInputFuture {
     type Output = Result<
         crate::input::PutWithContentEncodingInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-300
     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)
-307
+    }
-308
+}
-309
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-318
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-322
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-326
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-334
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),
-345
+        }
-346
+    }
-347
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PutWithContentEncodingOutput
-352
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-359
+                        }
-360
+                    }
-361
+    }
-362
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PutWithContentEncodingError
-367
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-377
+            }
-378
+        }
-379
+    }
-380
+}
-381
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`FractionalSecondsInput`](crate::input::FractionalSecondsInput) using modelled bindings.
     pub struct FractionalSecondsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::FractionalSecondsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::FractionalSecondsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-387
+    }
-388
+}
-389
 impl std::future::Future for FractionalSecondsInputFuture {
     type Output = Result<
         crate::input::FractionalSecondsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-395
     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)
-402
+    }
-403
+}
-404
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_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>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-417
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
-421
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-429
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
-432
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         FractionalSecondsInputFuture {
             inner: Box::pin(fut),
-442
+        }
-443
+    }
-444
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::FractionalSecondsOutput
-449
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-458
+            }
-459
+        }
-460
+    }
-461
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::FractionalSecondsError
-466
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-478
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-482
+            }
-483
+        }
-484
+    }
-485
+}
-486
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DatetimeOffsetsInput`](crate::input::DatetimeOffsetsInput) using modelled bindings.
     pub struct DatetimeOffsetsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DatetimeOffsetsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DatetimeOffsetsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-492
+    }
-493
+}
-494
 impl std::future::Future for DatetimeOffsetsInputFuture {
     type Output = Result<
         crate::input::DatetimeOffsetsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-500
     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)
-507
+    }
-508
+}
-509
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DatetimeOffsetsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-518
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-522
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DatetimeOffsetsInputFuture;
-526
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-534
+            }
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         DatetimeOffsetsInputFuture {
             inner: Box::pin(fut),
-545
+        }
-546
+    }
-547
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DatetimeOffsetsOutput
-552
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-561
+            }
-562
+        }
-563
+    }
-564
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::DatetimeOffsetsError
-569
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_error(&self)
-572
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-580
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-584
+            }
-585
+        }
-586
+    }
-587
+}
-588
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPostNoInputNoPayloadInput`](crate::input::TestPostNoInputNoPayloadInput) using modelled bindings.
     pub struct TestPostNoInputNoPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPostNoInputNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPostNoInputNoPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-594
+    }
-595
+}
-596
 impl std::future::Future for TestPostNoInputNoPayloadInputFuture {
     type Output = Result<
         crate::input::TestPostNoInputNoPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-602
     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)
-609
+    }
-610
+}
-611
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPostNoInputNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-620
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-624
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPostNoInputNoPayloadInputFuture;
-628
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-636
+            }
             crate::protocol_serde::shape_test_post_no_input_no_payload::de_test_post_no_input_no_payload_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestPostNoInputNoPayloadInputFuture {
             inner: Box::pin(fut),
-647
+        }
-648
+    }
-649
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPostNoInputNoPayloadOutput
-654
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-661
+                        }
-662
+                    }
-663
+    }
-664
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestPostNoInputNoPayloadError
-669
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_post_no_input_no_payload::ser_test_post_no_input_no_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-679
+            }
-680
+        }
-681
+    }
-682
+}
-683
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestGetNoInputNoPayloadInput`](crate::input::TestGetNoInputNoPayloadInput) using modelled bindings.
     pub struct TestGetNoInputNoPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestGetNoInputNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestGetNoInputNoPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-689
+    }
-690
+}
-691
 impl std::future::Future for TestGetNoInputNoPayloadInputFuture {
     type Output = Result<
         crate::input::TestGetNoInputNoPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-697
     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)
-704
+    }
-705
+}
-706
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestGetNoInputNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-715
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-719
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestGetNoInputNoPayloadInputFuture;
-723
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-731
+            }
             crate::protocol_serde::shape_test_get_no_input_no_payload::de_test_get_no_input_no_payload_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestGetNoInputNoPayloadInputFuture {
             inner: Box::pin(fut),
-742
+        }
-743
+    }
-744
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestGetNoInputNoPayloadOutput
-749
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-756
+                        }
-757
+                    }
-758
+    }
-759
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestGetNoInputNoPayloadError
-764
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_get_no_input_no_payload::ser_test_get_no_input_no_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-774
+            }
-775
+        }
-776
+    }
-777
+}
-778
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPostNoPayloadInput`](crate::input::TestPostNoPayloadInput) using modelled bindings.
     pub struct TestPostNoPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPostNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPostNoPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-784
+    }
-785
+}
-786
 impl std::future::Future for TestPostNoPayloadInputFuture {
     type Output = Result<
         crate::input::TestPostNoPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-792
     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)
-799
+    }
-800
+}
-801
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPostNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-810
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-814
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPostNoPayloadInputFuture;
-818
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-826
+            }
             crate::protocol_serde::shape_test_post_no_payload::de_test_post_no_payload_http_request(
                 request,
-829
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestPostNoPayloadInputFuture {
             inner: Box::pin(fut),
-839
+        }
-840
+    }
-841
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPostNoPayloadOutput
-846
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-853
+                        }
-854
+                    }
-855
+    }
-856
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestPostNoPayloadError
-861
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_post_no_payload::ser_test_post_no_payload_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-873
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-877
+            }
-878
+        }
-879
+    }
-880
+}
-881
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestGetNoPayloadInput`](crate::input::TestGetNoPayloadInput) using modelled bindings.
     pub struct TestGetNoPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestGetNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestGetNoPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-887
+    }
-888
+}
-889
 impl std::future::Future for TestGetNoPayloadInputFuture {
     type Output = Result<
         crate::input::TestGetNoPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-895
     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)
-902
+    }
-903
+}
-904
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestGetNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-913
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-917
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestGetNoPayloadInputFuture;
-921
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-929
+            }
             crate::protocol_serde::shape_test_get_no_payload::de_test_get_no_payload_http_request(
                 request,
-932
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestGetNoPayloadInputFuture {
             inner: Box::pin(fut),
-942
+        }
-943
+    }
-944
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestGetNoPayloadOutput
-949
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-956
+                        }
-957
+                    }
-958
+    }
-959
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestGetNoPayloadError
-964
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_get_no_payload::ser_test_get_no_payload_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-976
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-980
+            }
-981
+        }
-982
+    }
-983
+}
-984
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPayloadBlobInput`](crate::input::TestPayloadBlobInput) using modelled bindings.
     pub struct TestPayloadBlobInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadBlobInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadBlobInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-990
+    }
-991
+}
-992
 impl std::future::Future for TestPayloadBlobInputFuture {
     type Output = Result<
         crate::input::TestPayloadBlobInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-998
     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)
-1005
+    }
-1006
+}
-1007
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1016
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1020
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadBlobInputFuture;
-1024
     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,
-1029
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestPayloadBlobInputFuture {
             inner: Box::pin(fut),
-1039
+        }
-1040
+    }
-1041
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadBlobOutput
-1046
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1055
+            }
-1056
+        }
-1057
+    }
-1058
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestPayloadBlobError
-1063
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_blob::ser_test_payload_blob_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-1075
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1079
+            }
-1080
+        }
-1081
+    }
-1082
+}
-1083
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPayloadStructureInput`](crate::input::TestPayloadStructureInput) using modelled bindings.
     pub struct TestPayloadStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadStructureInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1089
+    }
-1090
+}
-1091
 impl std::future::Future for TestPayloadStructureInputFuture {
     type Output = Result<
         crate::input::TestPayloadStructureInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1097
     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)
-1104
+    }
-1105
+}
-1106
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1115
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1119
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadStructureInputFuture;
-1123
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1131
+            }
             crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestPayloadStructureInputFuture {
             inner: Box::pin(fut),
-1142
+        }
-1143
+    }
-1144
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadStructureOutput
-1149
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1156
+                        }
-1157
+                    }
-1158
+    }
-1159
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestPayloadStructureError
-1164
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_structure::ser_test_payload_structure_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1174
+            }
-1175
+        }
-1176
+    }
-1177
+}
-1178
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestBodyStructureInput`](crate::input::TestBodyStructureInput) using modelled bindings.
     pub struct TestBodyStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestBodyStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestBodyStructureInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1184
+    }
-1185
+}
-1186
 impl std::future::Future for TestBodyStructureInputFuture {
     type Output = Result<
         crate::input::TestBodyStructureInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1192
     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)
-1199
+    }
-1200
+}
-1201
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestBodyStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1210
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1214
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestBodyStructureInputFuture;
-1218
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1226
+            }
             crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_request(
                 request,
-1229
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TestBodyStructureInputFuture {
             inner: Box::pin(fut),
-1239
+        }
-1240
+    }
-1241
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestBodyStructureOutput
-1246
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1253
+                        }
-1254
+                    }
-1255
+    }
-1256
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TestBodyStructureError
-1261
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-1273
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1277
+            }
-1278
+        }
-1279
+    }
-1280
+}
-1281
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithGenericStringInput`](crate::input::MalformedAcceptWithGenericStringInput) using modelled bindings.
     pub struct MalformedAcceptWithGenericStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithGenericStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithGenericStringInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1287
+    }
-1288
+}
-1289
 impl std::future::Future for MalformedAcceptWithGenericStringInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithGenericStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1295
     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)
-1302
+    }
-1303
+}
-1304
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1313
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1317
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithGenericStringInputFuture;
-1321
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1329
+            }
             crate::protocol_serde::shape_malformed_accept_with_generic_string::de_malformed_accept_with_generic_string_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedAcceptWithGenericStringInputFuture {
             inner: Box::pin(fut),
-1340
+        }
-1341
+    }
-1342
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithGenericStringOutput
-1347
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1354
+                        }
-1355
+                    }
-1356
+    }
-1357
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedAcceptWithGenericStringError
-1362
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_generic_string::ser_malformed_accept_with_generic_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1372
+            }
-1373
+        }
-1374
+    }
-1375
+}
-1376
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithPayloadInput`](crate::input::MalformedAcceptWithPayloadInput) using modelled bindings.
     pub struct MalformedAcceptWithPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1382
+    }
-1383
+}
-1384
 impl std::future::Future for MalformedAcceptWithPayloadInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1390
     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)
-1397
+    }
-1398
+}
-1399
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1408
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1412
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithPayloadInputFuture;
-1416
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_IMAGE_JPEG,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1424
+            }
             crate::protocol_serde::shape_malformed_accept_with_payload::de_malformed_accept_with_payload_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedAcceptWithPayloadInputFuture {
             inner: Box::pin(fut),
-1435
+        }
-1436
+    }
-1437
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithPayloadOutput
-1442
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1449
+                        }
-1450
+                    }
-1451
+    }
-1452
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedAcceptWithPayloadError
-1457
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_payload::ser_malformed_accept_with_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1467
+            }
-1468
+        }
-1469
+    }
-1470
+}
-1471
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithBodyInput`](crate::input::MalformedAcceptWithBodyInput) using modelled bindings.
     pub struct MalformedAcceptWithBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithBodyInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1477
+    }
-1478
+}
-1479
 impl std::future::Future for MalformedAcceptWithBodyInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithBodyInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1485
     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)
-1492
+    }
-1493
+}
-1494
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1503
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1507
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithBodyInputFuture;
-1511
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1519
+            }
             crate::protocol_serde::shape_malformed_accept_with_body::de_malformed_accept_with_body_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedAcceptWithBodyInputFuture {
             inner: Box::pin(fut),
-1530
+        }
-1531
+    }
-1532
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithBodyOutput
-1537
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1544
+                        }
-1545
+                    }
-1546
+    }
-1547
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedAcceptWithBodyError
-1552
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_body::ser_malformed_accept_with_body_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1562
+            }
-1563
+        }
-1564
+    }
-1565
+}
-1566
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithGenericStringInput`](crate::input::MalformedContentTypeWithGenericStringInput) using modelled bindings.
     pub struct MalformedContentTypeWithGenericStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithGenericStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithGenericStringInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1572
+    }
-1573
+}
-1574
 impl std::future::Future for MalformedContentTypeWithGenericStringInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithGenericStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1580
     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)
-1587
+    }
-1588
+}
-1589
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_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>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1602
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithGenericStringInputFuture;
-1606
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1614
+            }
             crate::protocol_serde::shape_malformed_content_type_with_generic_string::de_malformed_content_type_with_generic_string_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedContentTypeWithGenericStringInputFuture {
             inner: Box::pin(fut),
-1625
+        }
-1626
+    }
-1627
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithGenericStringOutput
-1632
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1639
+                        }
-1640
+                    }
-1641
+    }
-1642
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedContentTypeWithGenericStringError
-1647
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_generic_string::ser_malformed_content_type_with_generic_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1657
+            }
-1658
+        }
-1659
+    }
-1660
+}
-1661
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithPayloadInput`](crate::input::MalformedContentTypeWithPayloadInput) using modelled bindings.
     pub struct MalformedContentTypeWithPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1667
+    }
-1668
+}
-1669
 impl std::future::Future for MalformedContentTypeWithPayloadInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1675
     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)
-1682
+    }
-1683
+}
-1684
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1693
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1697
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithPayloadInputFuture;
-1701
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1709
+            }
             crate::protocol_serde::shape_malformed_content_type_with_payload::de_malformed_content_type_with_payload_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedContentTypeWithPayloadInputFuture {
             inner: Box::pin(fut),
-1720
+        }
-1721
+    }
-1722
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithPayloadOutput
-1727
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1734
+                        }
-1735
+                    }
-1736
+    }
-1737
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedContentTypeWithPayloadError
-1742
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_payload::ser_malformed_content_type_with_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1752
+            }
-1753
+        }
-1754
+    }
-1755
+}
-1756
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithBodyInput`](crate::input::MalformedContentTypeWithBodyInput) using modelled bindings.
     pub struct MalformedContentTypeWithBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithBodyInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1762
+    }
-1763
+}
-1764
 impl std::future::Future for MalformedContentTypeWithBodyInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithBodyInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1770
     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)
-1777
+    }
-1778
+}
-1779
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1788
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1792
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithBodyInputFuture;
-1796
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1804
+            }
             crate::protocol_serde::shape_malformed_content_type_with_body::de_malformed_content_type_with_body_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedContentTypeWithBodyInputFuture {
             inner: Box::pin(fut),
-1815
+        }
-1816
+    }
-1817
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithBodyOutput
-1822
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1829
+                        }
-1830
+                    }
-1831
+    }
-1832
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedContentTypeWithBodyError
-1837
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_body::ser_malformed_content_type_with_body_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1847
+            }
-1848
+        }
-1849
+    }
-1850
+}
-1851
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithoutBodyEmptyInputInput`](crate::input::MalformedContentTypeWithoutBodyEmptyInputInput) using modelled bindings.
     pub struct MalformedContentTypeWithoutBodyEmptyInputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithoutBodyEmptyInputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithoutBodyEmptyInputInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1857
+    }
-1858
+}
-1859
 impl std::future::Future for MalformedContentTypeWithoutBodyEmptyInputInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithoutBodyEmptyInputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1865
     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)
-1872
+    }
-1873
+}
-1874
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithoutBodyEmptyInputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1883
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1887
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithoutBodyEmptyInputInputFuture;
-1891
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1899
+            }
             crate::protocol_serde::shape_malformed_content_type_without_body_empty_input::de_malformed_content_type_without_body_empty_input_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedContentTypeWithoutBodyEmptyInputInputFuture {
             inner: Box::pin(fut),
-1910
+        }
-1911
+    }
-1912
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithoutBodyEmptyInputOutput
-1917
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_without_body_empty_input::ser_malformed_content_type_without_body_empty_input_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1924
+                        }
-1925
+                    }
-1926
+    }
-1927
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedContentTypeWithoutBodyEmptyInputError
-1932
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_without_body_empty_input::ser_malformed_content_type_without_body_empty_input_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1942
+            }
-1943
+        }
-1944
+    }
-1945
+}
-1946
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithoutBodyInput`](crate::input::MalformedContentTypeWithoutBodyInput) using modelled bindings.
     pub struct MalformedContentTypeWithoutBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithoutBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithoutBodyInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1952
+    }
-1953
+}
-1954
 impl std::future::Future for MalformedContentTypeWithoutBodyInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithoutBodyInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-1960
     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)
-1967
+    }
-1968
+}
-1969
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithoutBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-1978
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-1982
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithoutBodyInputFuture;
-1986
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1994
+            }
             crate::protocol_serde::shape_malformed_content_type_without_body::de_malformed_content_type_without_body_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedContentTypeWithoutBodyInputFuture {
             inner: Box::pin(fut),
-2005
+        }
-2006
+    }
-2007
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithoutBodyOutput
-2012
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2019
+                        }
-2020
+                    }
-2021
+    }
-2022
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedContentTypeWithoutBodyError
-2027
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_without_body::ser_malformed_content_type_without_body_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2037
+            }
-2038
+        }
-2039
+    }
-2040
+}
-2041
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyHttpDateInput`](crate::input::MalformedTimestampBodyHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampBodyHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyHttpDateInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2047
+    }
-2048
+}
-2049
 impl std::future::Future for MalformedTimestampBodyHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyHttpDateInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2055
     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)
-2062
+    }
-2063
+}
-2064
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2073
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2077
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyHttpDateInputFuture;
-2081
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2089
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_http_date::de_malformed_timestamp_body_http_date_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampBodyHttpDateInputFuture {
             inner: Box::pin(fut),
-2100
+        }
-2101
+    }
-2102
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyHttpDateOutput
-2107
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2114
+                        }
-2115
+                    }
-2116
+    }
-2117
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyHttpDateError
-2122
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2132
+            }
-2133
+        }
-2134
+    }
-2135
+}
-2136
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyDateTimeInput`](crate::input::MalformedTimestampBodyDateTimeInput) using modelled bindings.
     pub struct MalformedTimestampBodyDateTimeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDateTimeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDateTimeInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2142
+    }
-2143
+}
-2144
 impl std::future::Future for MalformedTimestampBodyDateTimeInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyDateTimeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2150
     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)
-2157
+    }
-2158
+}
-2159
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2168
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2172
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDateTimeInputFuture;
-2176
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2184
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_date_time::de_malformed_timestamp_body_date_time_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampBodyDateTimeInputFuture {
             inner: Box::pin(fut),
-2195
+        }
-2196
+    }
-2197
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDateTimeOutput
-2202
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2209
+                        }
-2210
+                    }
-2211
+    }
-2212
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyDateTimeError
-2217
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2227
+            }
-2228
+        }
-2229
+    }
-2230
+}
-2231
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyDefaultInput`](crate::input::MalformedTimestampBodyDefaultInput) using modelled bindings.
     pub struct MalformedTimestampBodyDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDefaultInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2237
+    }
-2238
+}
-2239
 impl std::future::Future for MalformedTimestampBodyDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyDefaultInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2245
     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)
-2252
+    }
-2253
+}
-2254
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2263
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2267
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDefaultInputFuture;
-2271
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2279
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_default::de_malformed_timestamp_body_default_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampBodyDefaultInputFuture {
             inner: Box::pin(fut),
-2290
+        }
-2291
+    }
-2292
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDefaultOutput
-2297
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2304
+                        }
-2305
+                    }
-2306
+    }
-2307
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyDefaultError
-2312
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2322
+            }
-2323
+        }
-2324
+    }
-2325
+}
-2326
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderEpochInput`](crate::input::MalformedTimestampHeaderEpochInput) using modelled bindings.
     pub struct MalformedTimestampHeaderEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderEpochInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2332
+    }
-2333
+}
-2334
 impl std::future::Future for MalformedTimestampHeaderEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderEpochInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2340
     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)
-2347
+    }
-2348
+}
-2349
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2358
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2362
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderEpochInputFuture;
-2366
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2374
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_epoch::de_malformed_timestamp_header_epoch_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampHeaderEpochInputFuture {
             inner: Box::pin(fut),
-2385
+        }
-2386
+    }
-2387
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderEpochOutput
-2392
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2399
+                        }
-2400
+                    }
-2401
+    }
-2402
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderEpochError
-2407
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2417
+            }
-2418
+        }
-2419
+    }
-2420
+}
-2421
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderDateTimeInput`](crate::input::MalformedTimestampHeaderDateTimeInput) using modelled bindings.
     pub struct MalformedTimestampHeaderDateTimeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDateTimeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDateTimeInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2427
+    }
-2428
+}
-2429
 impl std::future::Future for MalformedTimestampHeaderDateTimeInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderDateTimeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2435
     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)
-2442
+    }
-2443
+}
-2444
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2453
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2457
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDateTimeInputFuture;
-2461
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2469
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_date_time::de_malformed_timestamp_header_date_time_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampHeaderDateTimeInputFuture {
             inner: Box::pin(fut),
-2480
+        }
-2481
+    }
-2482
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDateTimeOutput
-2487
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2494
+                        }
-2495
+                    }
-2496
+    }
-2497
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderDateTimeError
-2502
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2512
+            }
-2513
+        }
-2514
+    }
-2515
+}
-2516
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderDefaultInput`](crate::input::MalformedTimestampHeaderDefaultInput) using modelled bindings.
     pub struct MalformedTimestampHeaderDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDefaultInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2522
+    }
-2523
+}
-2524
 impl std::future::Future for MalformedTimestampHeaderDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderDefaultInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2530
     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)
-2537
+    }
-2538
+}
-2539
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2548
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2552
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDefaultInputFuture;
-2556
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2564
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_default::de_malformed_timestamp_header_default_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampHeaderDefaultInputFuture {
             inner: Box::pin(fut),
-2575
+        }
-2576
+    }
-2577
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDefaultOutput
-2582
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2589
+                        }
-2590
+                    }
-2591
+    }
-2592
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderDefaultError
-2597
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2607
+            }
-2608
+        }
-2609
+    }
-2610
+}
-2611
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryEpochInput`](crate::input::MalformedTimestampQueryEpochInput) using modelled bindings.
     pub struct MalformedTimestampQueryEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryEpochInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2617
+    }
-2618
+}
-2619
 impl std::future::Future for MalformedTimestampQueryEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryEpochInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2625
     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)
-2632
+    }
-2633
+}
-2634
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2643
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2647
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryEpochInputFuture;
-2651
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2659
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_epoch::de_malformed_timestamp_query_epoch_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampQueryEpochInputFuture {
             inner: Box::pin(fut),
-2670
+        }
-2671
+    }
-2672
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryEpochOutput
-2677
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2684
+                        }
-2685
+                    }
-2686
+    }
-2687
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryEpochError
-2692
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2702
+            }
-2703
+        }
-2704
+    }
-2705
+}
-2706
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryHttpDateInput`](crate::input::MalformedTimestampQueryHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampQueryHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryHttpDateInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2712
+    }
-2713
+}
-2714
 impl std::future::Future for MalformedTimestampQueryHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryHttpDateInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2720
     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)
-2727
+    }
-2728
+}
-2729
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2738
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2742
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryHttpDateInputFuture;
-2746
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2754
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_http_date::de_malformed_timestamp_query_http_date_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampQueryHttpDateInputFuture {
             inner: Box::pin(fut),
-2765
+        }
-2766
+    }
-2767
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryHttpDateOutput
-2772
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2779
+                        }
-2780
+                    }
-2781
+    }
-2782
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryHttpDateError
-2787
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2797
+            }
-2798
+        }
-2799
+    }
-2800
+}
-2801
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryDefaultInput`](crate::input::MalformedTimestampQueryDefaultInput) using modelled bindings.
     pub struct MalformedTimestampQueryDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryDefaultInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2807
+    }
-2808
+}
-2809
 impl std::future::Future for MalformedTimestampQueryDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryDefaultInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2815
     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)
-2822
+    }
-2823
+}
-2824
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2833
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2837
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryDefaultInputFuture;
-2841
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2849
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_default::de_malformed_timestamp_query_default_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampQueryDefaultInputFuture {
             inner: Box::pin(fut),
-2860
+        }
-2861
+    }
-2862
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryDefaultOutput
-2867
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2874
+                        }
-2875
+                    }
-2876
+    }
-2877
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryDefaultError
-2882
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2892
+            }
-2893
+        }
-2894
+    }
-2895
+}
-2896
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathEpochInput`](crate::input::MalformedTimestampPathEpochInput) using modelled bindings.
     pub struct MalformedTimestampPathEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathEpochInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2902
+    }
-2903
+}
-2904
 impl std::future::Future for MalformedTimestampPathEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathEpochInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-2910
     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)
-2917
+    }
-2918
+}
-2919
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-2928
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-2932
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathEpochInputFuture;
-2936
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2944
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_epoch::de_malformed_timestamp_path_epoch_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampPathEpochInputFuture {
             inner: Box::pin(fut),
-2955
+        }
-2956
+    }
-2957
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathEpochOutput
-2962
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2969
+                        }
-2970
+                    }
-2971
+    }
-2972
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathEpochError
-2977
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2987
+            }
-2988
+        }
-2989
+    }
-2990
+}
-2991
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathHttpDateInput`](crate::input::MalformedTimestampPathHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampPathHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathHttpDateInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2997
+    }
-2998
+}
-2999
 impl std::future::Future for MalformedTimestampPathHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathHttpDateInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3005
     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)
-3012
+    }
-3013
+}
-3014
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3023
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3027
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathHttpDateInputFuture;
-3031
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3039
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_http_date::de_malformed_timestamp_path_http_date_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampPathHttpDateInputFuture {
             inner: Box::pin(fut),
-3050
+        }
-3051
+    }
-3052
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathHttpDateOutput
-3057
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3064
+                        }
-3065
+                    }
-3066
+    }
-3067
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathHttpDateError
-3072
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3082
+            }
-3083
+        }
-3084
+    }
-3085
+}
-3086
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathDefaultInput`](crate::input::MalformedTimestampPathDefaultInput) using modelled bindings.
     pub struct MalformedTimestampPathDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathDefaultInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3092
+    }
-3093
+}
-3094
 impl std::future::Future for MalformedTimestampPathDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathDefaultInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3100
     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)
-3107
+    }
-3108
+}
-3109
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3118
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3122
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathDefaultInputFuture;
-3126
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3134
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_default::de_malformed_timestamp_path_default_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedTimestampPathDefaultInputFuture {
             inner: Box::pin(fut),
-3145
+        }
-3146
+    }
-3147
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathDefaultOutput
-3152
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3159
+                        }
-3160
+                    }
-3161
+    }
-3162
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathDefaultError
-3167
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3177
+            }
-3178
+        }
-3179
+    }
-3180
+}
-3181
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedStringInput`](crate::input::MalformedStringInput) using modelled bindings.
     pub struct MalformedStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedStringInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3187
+    }
-3188
+}
-3189
 impl std::future::Future for MalformedStringInputFuture {
     type Output = Result<
         crate::input::MalformedStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3195
     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)
-3202
+    }
-3203
+}
-3204
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3213
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3217
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedStringInputFuture;
-3221
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3229
+            }
             crate::protocol_serde::shape_malformed_string::de_malformed_string_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedStringInputFuture {
             inner: Box::pin(fut),
-3240
+        }
-3241
+    }
-3242
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedStringOutput
-3247
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3256
+            }
-3257
+        }
-3258
+    }
-3259
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedStringError
-3264
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_string::ser_malformed_string_http_error(&self)
-3267
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3275
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3279
+            }
-3280
+        }
-3281
+    }
-3282
+}
-3283
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedDoubleInput`](crate::input::MalformedDoubleInput) using modelled bindings.
     pub struct MalformedDoubleInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedDoubleInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedDoubleInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3289
+    }
-3290
+}
-3291
 impl std::future::Future for MalformedDoubleInputFuture {
     type Output = Result<
         crate::input::MalformedDoubleInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3297
     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)
-3304
+    }
-3305
+}
-3306
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedDoubleInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3315
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3319
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedDoubleInputFuture;
-3323
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3331
+            }
             crate::protocol_serde::shape_malformed_double::de_malformed_double_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedDoubleInputFuture {
             inner: Box::pin(fut),
-3342
+        }
-3343
+    }
-3344
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedDoubleOutput
-3349
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3358
+            }
-3359
+        }
-3360
+    }
-3361
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedDoubleError
-3366
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_error(&self)
-3369
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3377
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3381
+            }
-3382
+        }
-3383
+    }
-3384
+}
-3385
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedFloatInput`](crate::input::MalformedFloatInput) using modelled bindings.
     pub struct MalformedFloatInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedFloatInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedFloatInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3391
+    }
-3392
+}
-3393
 impl std::future::Future for MalformedFloatInputFuture {
     type Output = Result<
         crate::input::MalformedFloatInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3399
     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)
-3406
+    }
-3407
+}
-3408
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedFloatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3417
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3421
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedFloatInputFuture;
-3425
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3433
+            }
             crate::protocol_serde::shape_malformed_float::de_malformed_float_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedFloatInputFuture {
             inner: Box::pin(fut),
-3444
+        }
-3445
+    }
-3446
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedFloatOutput
-3451
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_response(self)
-3454
+        {
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3459
+            }
-3460
+        }
-3461
+    }
-3462
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedFloatError
-3467
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3477
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3481
+            }
-3482
+        }
-3483
+    }
-3484
+}
-3485
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedLongInput`](crate::input::MalformedLongInput) using modelled bindings.
     pub struct MalformedLongInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedLongInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedLongInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3491
+    }
-3492
+}
-3493
 impl std::future::Future for MalformedLongInputFuture {
     type Output = Result<
         crate::input::MalformedLongInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3499
     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)
-3506
+    }
-3507
+}
-3508
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLongInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3517
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3521
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLongInputFuture;
-3525
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3533
+            }
             crate::protocol_serde::shape_malformed_long::de_malformed_long_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedLongInputFuture {
             inner: Box::pin(fut),
-3544
+        }
-3545
+    }
-3546
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLongOutput
-3551
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3558
+            }
-3559
+        }
-3560
+    }
-3561
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedLongError
-3566
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3576
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3580
+            }
-3581
+        }
-3582
+    }
-3583
+}
-3584
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedShortInput`](crate::input::MalformedShortInput) using modelled bindings.
     pub struct MalformedShortInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedShortInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedShortInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3590
+    }
-3591
+}
-3592
 impl std::future::Future for MalformedShortInputFuture {
     type Output = Result<
         crate::input::MalformedShortInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3598
     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)
-3605
+    }
-3606
+}
-3607
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedShortInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3616
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3620
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedShortInputFuture;
-3624
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3632
+            }
             crate::protocol_serde::shape_malformed_short::de_malformed_short_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedShortInputFuture {
             inner: Box::pin(fut),
-3643
+        }
-3644
+    }
-3645
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedShortOutput
-3650
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_response(self)
-3653
+        {
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3658
+            }
-3659
+        }
-3660
+    }
-3661
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedShortError
-3666
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3676
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3680
+            }
-3681
+        }
-3682
+    }
-3683
+}
-3684
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedByteInput`](crate::input::MalformedByteInput) using modelled bindings.
     pub struct MalformedByteInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedByteInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedByteInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3690
+    }
-3691
+}
-3692
 impl std::future::Future for MalformedByteInputFuture {
     type Output = Result<
         crate::input::MalformedByteInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3698
     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)
-3705
+    }
-3706
+}
-3707
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedByteInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3716
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3720
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedByteInputFuture;
-3724
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3732
+            }
             crate::protocol_serde::shape_malformed_byte::de_malformed_byte_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedByteInputFuture {
             inner: Box::pin(fut),
-3743
+        }
-3744
+    }
-3745
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedByteOutput
-3750
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3757
+            }
-3758
+        }
-3759
+    }
-3760
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedByteError
-3765
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3775
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3779
+            }
-3780
+        }
-3781
+    }
-3782
+}
-3783
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedBlobInput`](crate::input::MalformedBlobInput) using modelled bindings.
     pub struct MalformedBlobInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBlobInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBlobInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3789
+    }
-3790
+}
-3791
 impl std::future::Future for MalformedBlobInputFuture {
     type Output = Result<
         crate::input::MalformedBlobInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3797
     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)
-3804
+    }
-3805
+}
-3806
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3815
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3819
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBlobInputFuture;
-3823
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3831
+            }
             crate::protocol_serde::shape_malformed_blob::de_malformed_blob_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedBlobInputFuture {
             inner: Box::pin(fut),
-3842
+        }
-3843
+    }
-3844
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBlobOutput
-3849
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3856
+            }
-3857
+        }
-3858
+    }
-3859
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedBlobError
-3864
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_blob::ser_malformed_blob_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3874
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3878
+            }
-3879
+        }
-3880
+    }
-3881
+}
-3882
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedMapInput`](crate::input::MalformedMapInput) using modelled bindings.
     pub struct MalformedMapInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedMapInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedMapInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3888
+    }
-3889
+}
-3890
 impl std::future::Future for MalformedMapInputFuture {
     type Output = Result<
         crate::input::MalformedMapInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3896
     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)
-3903
+    }
-3904
+}
-3905
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedMapInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-3914
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-3918
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedMapInputFuture;
-3922
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-3930
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedMapInputFuture {
             inner: Box::pin(fut),
-3940
+        }
-3941
+    }
-3942
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedMapOutput
-3947
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3954
+            }
-3955
+        }
-3956
+    }
-3957
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedMapError
-3962
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_map::ser_malformed_map_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-3972
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-3976
+            }
-3977
+        }
-3978
+    }
-3979
+}
-3980
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedListInput`](crate::input::MalformedListInput) using modelled bindings.
     pub struct MalformedListInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedListInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedListInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-3986
+    }
-3987
+}
-3988
 impl std::future::Future for MalformedListInputFuture {
     type Output = Result<
         crate::input::MalformedListInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-3994
     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)
-4001
+    }
-4002
+}
-4003
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedListInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4012
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4016
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedListInputFuture;
-4020
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4028
+            }
             crate::protocol_serde::shape_malformed_list::de_malformed_list_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedListInputFuture {
             inner: Box::pin(fut),
-4039
+        }
-4040
+    }
-4041
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedListOutput
-4046
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4053
+            }
-4054
+        }
-4055
+    }
-4056
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedListError
-4061
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_list::ser_malformed_list_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-4071
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4075
+            }
-4076
+        }
-4077
+    }
-4078
+}
-4079
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedBooleanInput`](crate::input::MalformedBooleanInput) using modelled bindings.
     pub struct MalformedBooleanInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBooleanInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBooleanInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4085
+    }
-4086
+}
-4087
 impl std::future::Future for MalformedBooleanInputFuture {
     type Output = Result<
         crate::input::MalformedBooleanInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4093
     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)
-4100
+    }
-4101
+}
-4102
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBooleanInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4111
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4115
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBooleanInputFuture;
-4119
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4127
+            }
             crate::protocol_serde::shape_malformed_boolean::de_malformed_boolean_http_request(
                 request,
-4130
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedBooleanInputFuture {
             inner: Box::pin(fut),
-4140
+        }
-4141
+    }
-4142
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBooleanOutput
-4147
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4156
+            }
-4157
+        }
-4158
+    }
-4159
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedBooleanError
-4164
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-4176
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4180
+            }
-4181
+        }
-4182
+    }
-4183
+}
-4184
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedUnionInput`](crate::input::MalformedUnionInput) using modelled bindings.
     pub struct MalformedUnionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedUnionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedUnionInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4190
+    }
-4191
+}
-4192
 impl std::future::Future for MalformedUnionInputFuture {
     type Output = Result<
         crate::input::MalformedUnionInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4198
     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)
-4205
+    }
-4206
+}
-4207
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4216
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4220
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUnionInputFuture;
-4224
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4232
+            }
             crate::protocol_serde::shape_malformed_union::de_malformed_union_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedUnionInputFuture {
             inner: Box::pin(fut),
-4243
+        }
-4244
+    }
-4245
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUnionOutput
-4250
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_union::ser_malformed_union_http_response(self)
-4253
+        {
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4258
+            }
-4259
+        }
-4260
+    }
-4261
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedUnionError
-4266
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_union::ser_malformed_union_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-4276
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4280
+            }
-4281
+        }
-4282
+    }
-4283
+}
-4284
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedIntegerInput`](crate::input::MalformedIntegerInput) using modelled bindings.
     pub struct MalformedIntegerInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedIntegerInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedIntegerInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4290
+    }
-4291
+}
-4292
 impl std::future::Future for MalformedIntegerInputFuture {
     type Output = Result<
         crate::input::MalformedIntegerInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4298
     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)
-4305
+    }
-4306
+}
-4307
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedIntegerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4316
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4320
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedIntegerInputFuture;
-4324
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4332
+            }
             crate::protocol_serde::shape_malformed_integer::de_malformed_integer_http_request(
                 request,
-4335
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedIntegerInputFuture {
             inner: Box::pin(fut),
-4345
+        }
-4346
+    }
-4347
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedIntegerOutput
-4352
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4361
+            }
-4362
+        }
-4363
+    }
-4364
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedIntegerError
-4369
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-4381
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4385
+            }
-4386
+        }
-4387
+    }
-4388
+}
-4389
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedRequestBodyInput`](crate::input::MalformedRequestBodyInput) using modelled bindings.
     pub struct MalformedRequestBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedRequestBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedRequestBodyInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4395
+    }
-4396
+}
-4397
 impl std::future::Future for MalformedRequestBodyInputFuture {
     type Output = Result<
         crate::input::MalformedRequestBodyInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4403
     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)
-4410
+    }
-4411
+}
-4412
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRequestBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4421
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4425
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRequestBodyInputFuture;
-4429
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4437
+            }
             crate::protocol_serde::shape_malformed_request_body::de_malformed_request_body_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MalformedRequestBodyInputFuture {
             inner: Box::pin(fut),
-4448
+        }
-4449
+    }
-4450
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRequestBodyOutput
-4455
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4462
+                        }
-4463
+                    }
-4464
+    }
-4465
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedRequestBodyError
-4470
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_request_body::ser_malformed_request_body_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4480
+            }
-4481
+        }
-4482
+    }
-4483
+}
-4484
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpChecksumRequiredInput`](crate::input::HttpChecksumRequiredInput) using modelled bindings.
     pub struct HttpChecksumRequiredInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpChecksumRequiredInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpChecksumRequiredInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4490
+    }
-4491
+}
-4492
 impl std::future::Future for HttpChecksumRequiredInputFuture {
     type Output = Result<
         crate::input::HttpChecksumRequiredInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4498
     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)
-4505
+    }
-4506
+}
-4507
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpChecksumRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4516
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4520
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpChecksumRequiredInputFuture;
-4524
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4532
+            }
             crate::protocol_serde::shape_http_checksum_required::de_http_checksum_required_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpChecksumRequiredInputFuture {
             inner: Box::pin(fut),
-4543
+        }
-4544
+    }
-4545
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpChecksumRequiredOutput
-4550
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4557
+                        }
-4558
+                    }
-4559
+    }
-4560
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpChecksumRequiredError
-4565
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_checksum_required::ser_http_checksum_required_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4575
+            }
-4576
+        }
-4577
+    }
-4578
+}
-4579
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HostWithPathOperationInput`](crate::input::HostWithPathOperationInput) using modelled bindings.
     pub struct HostWithPathOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HostWithPathOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HostWithPathOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4585
+    }
-4586
+}
-4587
 impl std::future::Future for HostWithPathOperationInputFuture {
     type Output = Result<
         crate::input::HostWithPathOperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4593
     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)
-4600
+    }
-4601
+}
-4602
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4611
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4615
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-4619
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4627
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),
-4638
+        }
-4639
+    }
-4640
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HostWithPathOperationOutput
-4645
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4652
+                        }
-4653
+                    }
-4654
+    }
-4655
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HostWithPathOperationError
-4660
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4670
+            }
-4671
+        }
-4672
+    }
-4673
+}
-4674
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput) using modelled bindings.
     pub struct EndpointWithHostLabelOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointWithHostLabelOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointWithHostLabelOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4680
+    }
-4681
+}
-4682
 impl std::future::Future for EndpointWithHostLabelOperationInputFuture {
     type Output = Result<
         crate::input::EndpointWithHostLabelOperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4688
     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)
-4695
+    }
-4696
+}
-4697
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4706
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4710
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-4714
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4722
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),
-4733
+        }
-4734
+    }
-4735
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointWithHostLabelOperationOutput
-4740
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4747
+                        }
-4748
+                    }
-4749
+    }
-4750
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EndpointWithHostLabelOperationError
-4755
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4765
+            }
-4766
+        }
-4767
+    }
-4768
+}
-4769
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EndpointOperationInput`](crate::input::EndpointOperationInput) using modelled bindings.
     pub struct EndpointOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4775
+    }
-4776
+}
-4777
 impl std::future::Future for EndpointOperationInputFuture {
     type Output = Result<
         crate::input::EndpointOperationInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4783
     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)
-4790
+    }
-4791
+}
-4792
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4801
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4805
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-4809
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4817
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-4820
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         EndpointOperationInputFuture {
             inner: Box::pin(fut),
-4830
+        }
-4831
+    }
-4832
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointOperationOutput
-4837
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4846
+            }
-4847
+        }
-4848
+    }
-4849
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EndpointOperationError
-4854
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-4866
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4870
+            }
-4871
+        }
-4872
+    }
-4873
+}
-4874
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PostUnionWithJsonNameInput`](crate::input::PostUnionWithJsonNameInput) using modelled bindings.
     pub struct PostUnionWithJsonNameInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostUnionWithJsonNameInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostUnionWithJsonNameInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4880
+    }
-4881
+}
-4882
 impl std::future::Future for PostUnionWithJsonNameInputFuture {
     type Output = Result<
         crate::input::PostUnionWithJsonNameInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4888
     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)
-4895
+    }
-4896
+}
-4897
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostUnionWithJsonNameInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-4906
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-4910
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostUnionWithJsonNameInputFuture;
-4914
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4922
+            }
             crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         PostUnionWithJsonNameInputFuture {
             inner: Box::pin(fut),
-4933
+        }
-4934
+    }
-4935
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostUnionWithJsonNameOutput
-4940
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4947
+                        }
-4948
+                    }
-4949
+    }
-4950
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PostUnionWithJsonNameError
-4955
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_post_union_with_json_name::ser_post_union_with_json_name_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4965
+            }
-4966
+        }
-4967
+    }
-4968
+}
-4969
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PostPlayerActionInput`](crate::input::PostPlayerActionInput) using modelled bindings.
     pub struct PostPlayerActionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostPlayerActionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostPlayerActionInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-4975
+    }
-4976
+}
-4977
 impl std::future::Future for PostPlayerActionInputFuture {
     type Output = Result<
         crate::input::PostPlayerActionInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-4983
     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)
-4990
+    }
-4991
+}
-4992
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostPlayerActionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5001
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5005
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostPlayerActionInputFuture;
-5009
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5017
+            }
             crate::protocol_serde::shape_post_player_action::de_post_player_action_http_request(
                 request,
-5020
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         PostPlayerActionInputFuture {
             inner: Box::pin(fut),
-5030
+        }
-5031
+    }
-5032
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostPlayerActionOutput
-5037
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5046
+            }
-5047
+        }
-5048
+    }
-5049
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PostPlayerActionError
-5054
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_post_player_action::ser_post_player_action_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5066
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5070
+            }
-5071
+        }
-5072
+    }
-5073
+}
-5074
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonUnionsInput`](crate::input::JsonUnionsInput) using modelled bindings.
     pub struct JsonUnionsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonUnionsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonUnionsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5080
+    }
-5081
+}
-5082
 impl std::future::Future for JsonUnionsInputFuture {
     type Output = Result<
         crate::input::JsonUnionsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5088
     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)
-5095
+    }
-5096
+}
-5097
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5106
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5110
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonUnionsInputFuture;
-5114
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5122
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonUnionsInputFuture {
             inner: Box::pin(fut),
-5132
+        }
-5133
+    }
-5134
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonUnionsOutput
-5139
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5146
+            }
-5147
+        }
-5148
+    }
-5149
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonUnionsError
-5154
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5164
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5168
+            }
-5169
+        }
-5170
+    }
-5171
+}
-5172
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DocumentTypeAsMapValueInput`](crate::input::DocumentTypeAsMapValueInput) using modelled bindings.
     pub struct DocumentTypeAsMapValueInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsMapValueInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsMapValueInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5178
+    }
-5179
+}
-5180
 impl std::future::Future for DocumentTypeAsMapValueInputFuture {
     type Output = Result<
         crate::input::DocumentTypeAsMapValueInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5186
     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)
-5193
+    }
-5194
+}
-5195
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeAsMapValueInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5204
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5208
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeAsMapValueInputFuture;
-5212
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5220
+            }
             crate::protocol_serde::shape_document_type_as_map_value::de_document_type_as_map_value_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         DocumentTypeAsMapValueInputFuture {
             inner: Box::pin(fut),
-5231
+        }
-5232
+    }
-5233
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeAsMapValueOutput
-5238
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5245
+                        }
-5246
+                    }
-5247
+    }
-5248
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::DocumentTypeAsMapValueError
-5253
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type_as_map_value::ser_document_type_as_map_value_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5263
+            }
-5264
+        }
-5265
+    }
-5266
+}
-5267
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DocumentTypeAsPayloadInput`](crate::input::DocumentTypeAsPayloadInput) using modelled bindings.
     pub struct DocumentTypeAsPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5273
+    }
-5274
+}
-5275
 impl std::future::Future for DocumentTypeAsPayloadInputFuture {
     type Output = Result<
         crate::input::DocumentTypeAsPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5281
     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)
-5288
+    }
-5289
+}
-5290
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeAsPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5299
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5303
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeAsPayloadInputFuture;
-5307
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5315
+            }
             crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         DocumentTypeAsPayloadInputFuture {
             inner: Box::pin(fut),
-5326
+        }
-5327
+    }
-5328
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeAsPayloadOutput
-5333
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5340
+                        }
-5341
+                    }
-5342
+    }
-5343
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::DocumentTypeAsPayloadError
-5348
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type_as_payload::ser_document_type_as_payload_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5358
+            }
-5359
+        }
-5360
+    }
-5361
+}
-5362
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DocumentTypeInput`](crate::input::DocumentTypeInput) using modelled bindings.
     pub struct DocumentTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5368
+    }
-5369
+}
-5370
 impl std::future::Future for DocumentTypeInputFuture {
     type Output = Result<
         crate::input::DocumentTypeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5376
     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)
-5383
+    }
-5384
+}
-5385
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5394
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5398
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeInputFuture;
-5402
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5410
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         DocumentTypeInputFuture {
             inner: Box::pin(fut),
-5420
+        }
-5421
+    }
-5422
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeOutput
-5427
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5434
+            }
-5435
+        }
-5436
+    }
-5437
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::DocumentTypeError
-5442
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type::ser_document_type_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5452
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5456
+            }
-5457
+        }
-5458
+    }
-5459
+}
-5460
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonBlobsInput`](crate::input::JsonBlobsInput) using modelled bindings.
     pub struct JsonBlobsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonBlobsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonBlobsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5466
+    }
-5467
+}
-5468
 impl std::future::Future for JsonBlobsInputFuture {
     type Output = Result<
         crate::input::JsonBlobsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5474
     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)
-5481
+    }
-5482
+}
-5483
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonBlobsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5492
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5496
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonBlobsInputFuture;
-5500
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5508
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonBlobsInputFuture {
             inner: Box::pin(fut),
-5518
+        }
-5519
+    }
-5520
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonBlobsOutput
-5525
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5532
+            }
-5533
+        }
-5534
+    }
-5535
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonBlobsError
-5540
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_blobs::ser_json_blobs_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5550
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5554
+            }
-5555
+        }
-5556
+    }
-5557
+}
-5558
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SparseJsonMapsInput`](crate::input::SparseJsonMapsInput) using modelled bindings.
     pub struct SparseJsonMapsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonMapsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonMapsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5564
+    }
-5565
+}
-5566
 impl std::future::Future for SparseJsonMapsInputFuture {
     type Output = Result<
         crate::input::SparseJsonMapsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5572
     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)
-5579
+    }
-5580
+}
-5581
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SparseJsonMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5590
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5594
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SparseJsonMapsInputFuture;
-5598
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5606
+            }
             crate::protocol_serde::shape_sparse_json_maps::de_sparse_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         SparseJsonMapsInputFuture {
             inner: Box::pin(fut),
-5617
+        }
-5618
+    }
-5619
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SparseJsonMapsOutput
-5624
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5633
+            }
-5634
+        }
-5635
+    }
-5636
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::SparseJsonMapsError
-5641
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_error(&self)
-5644
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5652
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5656
+            }
-5657
+        }
-5658
+    }
-5659
+}
-5660
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonMapsInput`](crate::input::JsonMapsInput) using modelled bindings.
     pub struct JsonMapsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonMapsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonMapsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5666
+    }
-5667
+}
-5668
 impl std::future::Future for JsonMapsInputFuture {
     type Output = Result<
         crate::input::JsonMapsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5674
     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)
-5681
+    }
-5682
+}
-5683
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5692
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5696
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonMapsInputFuture;
-5700
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5708
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonMapsInputFuture {
             inner: Box::pin(fut),
-5718
+        }
-5719
+    }
-5720
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonMapsOutput
-5725
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5732
+            }
-5733
+        }
-5734
+    }
-5735
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonMapsError
-5740
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_maps::ser_json_maps_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5750
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5754
+            }
-5755
+        }
-5756
+    }
-5757
+}
-5758
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SparseJsonListsInput`](crate::input::SparseJsonListsInput) using modelled bindings.
     pub struct SparseJsonListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonListsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5764
+    }
-5765
+}
-5766
 impl std::future::Future for SparseJsonListsInputFuture {
     type Output = Result<
         crate::input::SparseJsonListsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5772
     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)
-5779
+    }
-5780
+}
-5781
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SparseJsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5790
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5794
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SparseJsonListsInputFuture;
-5798
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5806
+            }
             crate::protocol_serde::shape_sparse_json_lists::de_sparse_json_lists_http_request(
                 request,
-5809
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         SparseJsonListsInputFuture {
             inner: Box::pin(fut),
-5819
+        }
-5820
+    }
-5821
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SparseJsonListsOutput
-5826
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5835
+            }
-5836
+        }
-5837
+    }
-5838
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::SparseJsonListsError
-5843
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_lists::ser_sparse_json_lists_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5855
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5859
+            }
-5860
+        }
-5861
+    }
-5862
+}
-5863
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonListsInput`](crate::input::JsonListsInput) using modelled bindings.
     pub struct JsonListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonListsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5869
+    }
-5870
+}
-5871
 impl std::future::Future for JsonListsInputFuture {
     type Output = Result<
         crate::input::JsonListsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5877
     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)
-5884
+    }
-5885
+}
-5886
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5895
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5899
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonListsInputFuture;
-5903
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5911
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonListsInputFuture {
             inner: Box::pin(fut),
-5921
+        }
-5922
+    }
-5923
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonListsOutput
-5928
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5935
+            }
-5936
+        }
-5937
+    }
-5938
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonListsError
-5943
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_lists::ser_json_lists_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-5953
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5957
+            }
-5958
+        }
-5959
+    }
-5960
+}
-5961
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`RecursiveShapesInput`](crate::input::RecursiveShapesInput) using modelled bindings.
     pub struct RecursiveShapesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::RecursiveShapesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::RecursiveShapesInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-5967
+    }
-5968
+}
-5969
 impl std::future::Future for RecursiveShapesInputFuture {
     type Output = Result<
         crate::input::RecursiveShapesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-5975
     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)
-5982
+    }
-5983
+}
-5984
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RecursiveShapesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-5993
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-5997
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RecursiveShapesInputFuture;
-6001
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6009
+            }
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         RecursiveShapesInputFuture {
             inner: Box::pin(fut),
-6020
+        }
-6021
+    }
-6022
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RecursiveShapesOutput
-6027
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6036
+            }
-6037
+        }
-6038
+    }
-6039
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::RecursiveShapesError
-6044
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_http_error(&self)
-6047
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-6055
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6059
+            }
-6060
+        }
-6061
+    }
-6062
+}
-6063
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonIntEnumsInput`](crate::input::JsonIntEnumsInput) using modelled bindings.
     pub struct JsonIntEnumsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonIntEnumsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonIntEnumsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6069
+    }
-6070
+}
-6071
 impl std::future::Future for JsonIntEnumsInputFuture {
     type Output = Result<
         crate::input::JsonIntEnumsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6077
     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)
-6084
+    }
-6085
+}
-6086
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonIntEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6095
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6099
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonIntEnumsInputFuture;
-6103
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6111
+            }
             crate::protocol_serde::shape_json_int_enums::de_json_int_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonIntEnumsInputFuture {
             inner: Box::pin(fut),
-6122
+        }
-6123
+    }
-6124
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonIntEnumsOutput
-6129
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6136
+            }
-6137
+        }
-6138
+    }
-6139
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonIntEnumsError
-6144
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-6154
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6158
+            }
-6159
+        }
-6160
+    }
-6161
+}
-6162
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonEnumsInput`](crate::input::JsonEnumsInput) using modelled bindings.
     pub struct JsonEnumsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonEnumsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonEnumsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6168
+    }
-6169
+}
-6170
 impl std::future::Future for JsonEnumsInputFuture {
     type Output = Result<
         crate::input::JsonEnumsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6176
     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)
-6183
+    }
-6184
+}
-6185
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6194
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6198
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonEnumsInputFuture;
-6202
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6210
+            }
             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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonEnumsInputFuture {
             inner: Box::pin(fut),
-6220
+        }
-6221
+    }
-6222
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonEnumsOutput
-6227
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6234
+            }
-6235
+        }
-6236
+    }
-6237
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonEnumsError
-6242
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-6252
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6256
+            }
-6257
+        }
-6258
+    }
-6259
+}
-6260
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonTimestampsInput`](crate::input::JsonTimestampsInput) using modelled bindings.
     pub struct JsonTimestampsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonTimestampsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonTimestampsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6266
+    }
-6267
+}
-6268
 impl std::future::Future for JsonTimestampsInputFuture {
     type Output = Result<
         crate::input::JsonTimestampsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6274
     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)
-6281
+    }
-6282
+}
-6283
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonTimestampsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6292
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6296
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonTimestampsInputFuture;
-6300
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6308
+            }
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         JsonTimestampsInputFuture {
             inner: Box::pin(fut),
-6319
+        }
-6320
+    }
-6321
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonTimestampsOutput
-6326
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_http_response(self)
-6329
+        {
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6334
+            }
-6335
+        }
-6336
+    }
-6337
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonTimestampsError
-6342
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-6352
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6356
+            }
-6357
+        }
-6358
+    }
-6359
+}
-6360
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SimpleScalarPropertiesInput`](crate::input::SimpleScalarPropertiesInput) using modelled bindings.
     pub struct SimpleScalarPropertiesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SimpleScalarPropertiesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SimpleScalarPropertiesInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6366
+    }
-6367
+}
-6368
 impl std::future::Future for SimpleScalarPropertiesInputFuture {
     type Output = Result<
         crate::input::SimpleScalarPropertiesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6374
     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)
-6381
+    }
-6382
+}
-6383
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6392
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6396
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-6400
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6408
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),
-6419
+        }
-6420
+    }
-6421
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SimpleScalarPropertiesOutput
-6426
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6433
+                        }
-6434
+                    }
-6435
+    }
-6436
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::SimpleScalarPropertiesError
-6441
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6451
+            }
-6452
+        }
-6453
+    }
-6454
+}
-6455
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`GreetingWithErrorsInput`](crate::input::GreetingWithErrorsInput) using modelled bindings.
     pub struct GreetingWithErrorsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::GreetingWithErrorsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::GreetingWithErrorsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6461
+    }
-6462
+}
-6463
 impl std::future::Future for GreetingWithErrorsInputFuture {
     type Output = Result<
         crate::input::GreetingWithErrorsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6469
     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)
-6476
+    }
-6477
+}
-6478
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6487
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6491
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-6495
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6503
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-6506
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),
-6516
+        }
-6517
+    }
-6518
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GreetingWithErrorsOutput
-6523
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6530
+                        }
-6531
+                    }
-6532
+    }
-6533
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::GreetingWithErrorsError
-6538
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-6550
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6554
+            }
-6555
+        }
-6556
+    }
-6557
+}
-6558
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StreamingTraitsWithMediaTypeInput`](crate::input::StreamingTraitsWithMediaTypeInput) using modelled bindings.
     pub struct StreamingTraitsWithMediaTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsWithMediaTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsWithMediaTypeInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6564
+    }
-6565
+}
-6566
 impl std::future::Future for StreamingTraitsWithMediaTypeInputFuture {
     type Output = Result<
         crate::input::StreamingTraitsWithMediaTypeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6572
     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)
-6579
+    }
-6580
+}
-6581
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6590
     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>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6595
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsWithMediaTypeInputFuture;
-6599
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6607
+            }
             crate::protocol_serde::shape_streaming_traits_with_media_type::de_streaming_traits_with_media_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         StreamingTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
-6618
+        }
-6619
+    }
-6620
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsWithMediaTypeOutput
-6625
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6632
+                        }
-6633
+                    }
-6634
+    }
-6635
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StreamingTraitsWithMediaTypeError
-6640
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits_with_media_type::ser_streaming_traits_with_media_type_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6650
+            }
-6651
+        }
-6652
+    }
-6653
+}
-6654
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StreamingTraitsRequireLengthInput`](crate::input::StreamingTraitsRequireLengthInput) using modelled bindings.
     pub struct StreamingTraitsRequireLengthInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsRequireLengthInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsRequireLengthInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6660
+    }
-6661
+}
-6662
 impl std::future::Future for StreamingTraitsRequireLengthInputFuture {
     type Output = Result<
         crate::input::StreamingTraitsRequireLengthInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6668
     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)
-6675
+    }
-6676
+}
-6677
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsRequireLengthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6686
     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>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6691
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsRequireLengthInputFuture;
-6695
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6703
+            }
             crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         StreamingTraitsRequireLengthInputFuture {
             inner: Box::pin(fut),
-6714
+        }
-6715
+    }
-6716
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsRequireLengthOutput
-6721
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6728
+                        }
-6729
+                    }
-6730
+    }
-6731
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StreamingTraitsRequireLengthError
-6736
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits_require_length::ser_streaming_traits_require_length_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6746
+            }
-6747
+        }
-6748
+    }
-6749
+}
-6750
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StreamingTraitsInput`](crate::input::StreamingTraitsInput) using modelled bindings.
     pub struct StreamingTraitsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6756
+    }
-6757
+}
-6758
 impl std::future::Future for StreamingTraitsInputFuture {
     type Output = Result<
         crate::input::StreamingTraitsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6764
     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)
-6771
+    }
-6772
+}
-6773
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6782
     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>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6787
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsInputFuture;
-6791
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_OCTET_STREAM,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6799
+            }
             crate::protocol_serde::shape_streaming_traits::de_streaming_traits_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         StreamingTraitsInputFuture {
             inner: Box::pin(fut),
-6810
+        }
-6811
+    }
-6812
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsOutput
-6817
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6826
+            }
-6827
+        }
-6828
+    }
-6829
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StreamingTraitsError
-6834
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits::ser_streaming_traits_http_error(&self)
-6837
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-6845
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6849
+            }
-6850
+        }
-6851
+    }
-6852
+}
-6853
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ResponseCodeHttpFallbackInput`](crate::input::ResponseCodeHttpFallbackInput) using modelled bindings.
     pub struct ResponseCodeHttpFallbackInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ResponseCodeHttpFallbackInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ResponseCodeHttpFallbackInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6859
+    }
-6860
+}
-6861
 impl std::future::Future for ResponseCodeHttpFallbackInputFuture {
     type Output = Result<
         crate::input::ResponseCodeHttpFallbackInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6867
     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)
-6874
+    }
-6875
+}
-6876
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeHttpFallbackInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6885
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6889
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeHttpFallbackInputFuture;
-6893
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6901
+            }
             crate::protocol_serde::shape_response_code_http_fallback::de_response_code_http_fallback_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         ResponseCodeHttpFallbackInputFuture {
             inner: Box::pin(fut),
-6912
+        }
-6913
+    }
-6914
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeHttpFallbackOutput
-6919
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_http_fallback::ser_response_code_http_fallback_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6926
+                        }
-6927
+                    }
-6928
+    }
-6929
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ResponseCodeHttpFallbackError
-6934
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_http_fallback::ser_response_code_http_fallback_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6944
+            }
-6945
+        }
-6946
+    }
-6947
+}
-6948
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ResponseCodeRequiredInput`](crate::input::ResponseCodeRequiredInput) using modelled bindings.
     pub struct ResponseCodeRequiredInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ResponseCodeRequiredInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ResponseCodeRequiredInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-6954
+    }
-6955
+}
-6956
 impl std::future::Future for ResponseCodeRequiredInputFuture {
     type Output = Result<
         crate::input::ResponseCodeRequiredInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-6962
     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)
-6969
+    }
-6970
+}
-6971
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ResponseCodeRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-6980
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-6984
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ResponseCodeRequiredInputFuture;
-6988
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6996
+            }
             crate::protocol_serde::shape_response_code_required::de_response_code_required_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         ResponseCodeRequiredInputFuture {
             inner: Box::pin(fut),
-7007
+        }
-7008
+    }
-7009
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ResponseCodeRequiredOutput
-7014
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_required::ser_response_code_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7021
+                        }
-7022
+                    }
-7023
+    }
-7024
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ResponseCodeRequiredError
-7029
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_response_code_required::ser_response_code_required_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7039
+            }
-7040
+        }
-7041
+    }
-7042
+}
-7043
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpResponseCodeInput`](crate::input::HttpResponseCodeInput) using modelled bindings.
     pub struct HttpResponseCodeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpResponseCodeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpResponseCodeInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7049
+    }
-7050
+}
-7051
 impl std::future::Future for HttpResponseCodeInputFuture {
     type Output = Result<
         crate::input::HttpResponseCodeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7057
     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)
-7064
+    }
-7065
+}
-7066
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpResponseCodeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7075
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7079
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpResponseCodeInputFuture;
-7083
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7091
+            }
             crate::protocol_serde::shape_http_response_code::de_http_response_code_http_request(
                 request,
-7094
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpResponseCodeInputFuture {
             inner: Box::pin(fut),
-7104
+        }
-7105
+    }
-7106
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpResponseCodeOutput
-7111
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7120
+            }
-7121
+        }
-7122
+    }
-7123
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpResponseCodeError
-7128
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_response_code::ser_http_response_code_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-7140
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7144
+            }
-7145
+        }
-7146
+    }
-7147
+}
-7148
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadWithUnionInput`](crate::input::HttpPayloadWithUnionInput) using modelled bindings.
     pub struct HttpPayloadWithUnionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithUnionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithUnionInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7154
+    }
-7155
+}
-7156
 impl std::future::Future for HttpPayloadWithUnionInputFuture {
     type Output = Result<
         crate::input::HttpPayloadWithUnionInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7162
     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)
-7169
+    }
-7170
+}
-7171
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadWithUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7180
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7184
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadWithUnionInputFuture;
-7188
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7196
+            }
             crate::protocol_serde::shape_http_payload_with_union::de_http_payload_with_union_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpPayloadWithUnionInputFuture {
             inner: Box::pin(fut),
-7207
+        }
-7208
+    }
-7209
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadWithUnionOutput
-7214
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7221
+                        }
-7222
+                    }
-7223
+    }
-7224
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPayloadWithUnionError
-7229
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_with_union::ser_http_payload_with_union_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7239
+            }
-7240
+        }
-7241
+    }
-7242
+}
-7243
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpStringPayloadInput`](crate::input::HttpStringPayloadInput) using modelled bindings.
     pub struct HttpStringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpStringPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpStringPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7249
+    }
-7250
+}
-7251
 impl std::future::Future for HttpStringPayloadInputFuture {
     type Output = Result<
         crate::input::HttpStringPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7257
     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)
-7264
+    }
-7265
+}
-7266
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpStringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7275
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7279
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpStringPayloadInputFuture;
-7283
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7291
+            }
             crate::protocol_serde::shape_http_string_payload::de_http_string_payload_http_request(
                 request,
-7294
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpStringPayloadInputFuture {
             inner: Box::pin(fut),
-7304
+        }
-7305
+    }
-7306
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpStringPayloadOutput
-7311
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7318
+                        }
-7319
+                    }
-7320
+    }
-7321
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpStringPayloadError
-7326
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_string_payload::ser_http_string_payload_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-7338
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7342
+            }
-7343
+        }
-7344
+    }
-7345
+}
-7346
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpEnumPayloadInput`](crate::input::HttpEnumPayloadInput) using modelled bindings.
     pub struct HttpEnumPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEnumPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEnumPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7352
+    }
-7353
+}
-7354
 impl std::future::Future for HttpEnumPayloadInputFuture {
     type Output = Result<
         crate::input::HttpEnumPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7360
     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)
-7367
+    }
-7368
+}
-7369
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpEnumPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7378
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7382
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpEnumPayloadInputFuture;
-7386
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7394
+            }
             crate::protocol_serde::shape_http_enum_payload::de_http_enum_payload_http_request(
                 request,
-7397
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpEnumPayloadInputFuture {
             inner: Box::pin(fut),
-7407
+        }
-7408
+    }
-7409
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpEnumPayloadOutput
-7414
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7423
+            }
-7424
+        }
-7425
+    }
-7426
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpEnumPayloadError
-7431
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-7443
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7447
+            }
-7448
+        }
-7449
+    }
-7450
+}
-7451
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadWithStructureInput`](crate::input::HttpPayloadWithStructureInput) using modelled bindings.
     pub struct HttpPayloadWithStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithStructureInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7457
+    }
-7458
+}
-7459
 impl std::future::Future for HttpPayloadWithStructureInputFuture {
     type Output = Result<
         crate::input::HttpPayloadWithStructureInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7465
     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)
-7472
+    }
-7473
+}
-7474
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadWithStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7483
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7487
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadWithStructureInputFuture;
-7491
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7499
+            }
             crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_structure_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpPayloadWithStructureInputFuture {
             inner: Box::pin(fut),
-7510
+        }
-7511
+    }
-7512
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadWithStructureOutput
-7517
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7524
+                        }
-7525
+                    }
-7526
+    }
-7527
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPayloadWithStructureError
-7532
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_with_structure::ser_http_payload_with_structure_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7542
+            }
-7543
+        }
-7544
+    }
-7545
+}
-7546
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadTraitsWithMediaTypeInput`](crate::input::HttpPayloadTraitsWithMediaTypeInput) using modelled bindings.
     pub struct HttpPayloadTraitsWithMediaTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsWithMediaTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsWithMediaTypeInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7552
+    }
-7553
+}
-7554
 impl std::future::Future for HttpPayloadTraitsWithMediaTypeInputFuture {
     type Output = Result<
         crate::input::HttpPayloadTraitsWithMediaTypeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7560
     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)
-7567
+    }
-7568
+}
-7569
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7578
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7582
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraitsWithMediaTypeInputFuture;
-7586
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7594
+            }
             crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpPayloadTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
-7605
+        }
-7606
+    }
-7607
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsWithMediaTypeOutput
-7612
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7619
+                        }
-7620
+                    }
-7621
+    }
-7622
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPayloadTraitsWithMediaTypeError
-7627
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits_with_media_type::ser_http_payload_traits_with_media_type_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7637
+            }
-7638
+        }
-7639
+    }
-7640
+}
-7641
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadTraitsInput`](crate::input::HttpPayloadTraitsInput) using modelled bindings.
     pub struct HttpPayloadTraitsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7647
+    }
-7648
+}
-7649
 impl std::future::Future for HttpPayloadTraitsInputFuture {
     type Output = Result<
         crate::input::HttpPayloadTraitsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7655
     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)
-7662
+    }
-7663
+}
-7664
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7673
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7677
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraitsInputFuture;
-7681
     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,
-7686
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpPayloadTraitsInputFuture {
             inner: Box::pin(fut),
-7696
+        }
-7697
+    }
-7698
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsOutput
-7703
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7710
+                        }
-7711
+                    }
-7712
+    }
-7713
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPayloadTraitsError
-7718
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits::ser_http_payload_traits_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-7730
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7734
+            }
-7735
+        }
-7736
+    }
-7737
+}
-7738
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpEmptyPrefixHeadersInput`](crate::input::HttpEmptyPrefixHeadersInput) using modelled bindings.
     pub struct HttpEmptyPrefixHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEmptyPrefixHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEmptyPrefixHeadersInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7744
+    }
-7745
+}
-7746
 impl std::future::Future for HttpEmptyPrefixHeadersInputFuture {
     type Output = Result<
         crate::input::HttpEmptyPrefixHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7752
     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)
-7759
+    }
-7760
+}
-7761
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpEmptyPrefixHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7770
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7774
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpEmptyPrefixHeadersInputFuture;
-7778
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7786
+            }
             crate::protocol_serde::shape_http_empty_prefix_headers::de_http_empty_prefix_headers_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpEmptyPrefixHeadersInputFuture {
             inner: Box::pin(fut),
-7797
+        }
-7798
+    }
-7799
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpEmptyPrefixHeadersOutput
-7804
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_empty_prefix_headers::ser_http_empty_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7811
+                        }
-7812
+                    }
-7813
+    }
-7814
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpEmptyPrefixHeadersError
-7819
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_empty_prefix_headers::ser_http_empty_prefix_headers_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7829
+            }
-7830
+        }
-7831
+    }
-7832
+}
-7833
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPrefixHeadersInResponseInput`](crate::input::HttpPrefixHeadersInResponseInput) using modelled bindings.
     pub struct HttpPrefixHeadersInResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInResponseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7839
+    }
-7840
+}
-7841
 impl std::future::Future for HttpPrefixHeadersInResponseInputFuture {
     type Output = Result<
         crate::input::HttpPrefixHeadersInResponseInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7847
     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)
-7854
+    }
-7855
+}
-7856
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersInResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7865
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7869
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersInResponseInputFuture;
-7873
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7881
+            }
             crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpPrefixHeadersInResponseInputFuture {
             inner: Box::pin(fut),
-7892
+        }
-7893
+    }
-7894
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersInResponseOutput
-7899
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7906
+                        }
-7907
+                    }
-7908
+    }
-7909
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPrefixHeadersInResponseError
-7914
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers_in_response::ser_http_prefix_headers_in_response_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7924
+            }
-7925
+        }
-7926
+    }
-7927
+}
-7928
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPrefixHeadersInput`](crate::input::HttpPrefixHeadersInput) using modelled bindings.
     pub struct HttpPrefixHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-7934
+    }
-7935
+}
-7936
 impl std::future::Future for HttpPrefixHeadersInputFuture {
     type Output = Result<
         crate::input::HttpPrefixHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-7942
     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)
-7949
+    }
-7950
+}
-7951
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-7960
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-7964
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersInputFuture;
-7968
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7976
+            }
             crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_http_request(
                 request,
-7979
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpPrefixHeadersInputFuture {
             inner: Box::pin(fut),
-7989
+        }
-7990
+    }
-7991
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersOutput
-7996
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8003
+                        }
-8004
+                    }
-8005
+    }
-8006
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpPrefixHeadersError
-8011
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers::ser_http_prefix_headers_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-8023
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8027
+            }
-8028
+        }
-8029
+    }
-8030
+}
-8031
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryParamsAsStringListMapInput`](crate::input::QueryParamsAsStringListMapInput) using modelled bindings.
     pub struct QueryParamsAsStringListMapInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryParamsAsStringListMapInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryParamsAsStringListMapInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8037
+    }
-8038
+}
-8039
 impl std::future::Future for QueryParamsAsStringListMapInputFuture {
     type Output = Result<
         crate::input::QueryParamsAsStringListMapInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8045
     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)
-8052
+    }
-8053
+}
-8054
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsAsStringListMapInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8063
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8067
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsAsStringListMapInputFuture;
-8071
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8079
+            }
             crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         QueryParamsAsStringListMapInputFuture {
             inner: Box::pin(fut),
-8090
+        }
-8091
+    }
-8092
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsAsStringListMapOutput
-8097
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8104
+                        }
-8105
+                    }
-8106
+    }
-8107
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryParamsAsStringListMapError
-8112
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_as_string_list_map::ser_query_params_as_string_list_map_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8122
+            }
-8123
+        }
-8124
+    }
-8125
+}
-8126
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8132
+    }
-8133
+}
-8134
 impl std::future::Future for QueryPrecedenceInputFuture {
     type Output = Result<
         crate::input::QueryPrecedenceInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8140
     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)
-8147
+    }
-8148
+}
-8149
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8158
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8162
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
-8166
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8174
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-8185
+        }
-8186
+    }
-8187
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
-8192
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8201
+            }
-8202
+        }
-8203
+    }
-8204
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryPrecedenceError
-8209
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_error(&self)
-8212
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-8220
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8224
+            }
-8225
+        }
-8226
+    }
-8227
+}
-8228
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryIdempotencyTokenAutoFillInput`](crate::input::QueryIdempotencyTokenAutoFillInput) using modelled bindings.
     pub struct QueryIdempotencyTokenAutoFillInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryIdempotencyTokenAutoFillInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryIdempotencyTokenAutoFillInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8234
+    }
-8235
+}
-8236
 impl std::future::Future for QueryIdempotencyTokenAutoFillInputFuture {
     type Output = Result<
         crate::input::QueryIdempotencyTokenAutoFillInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8242
     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)
-8249
+    }
-8250
+}
-8251
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryIdempotencyTokenAutoFillInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8260
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8264
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryIdempotencyTokenAutoFillInputFuture;
-8268
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8276
+            }
             crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         QueryIdempotencyTokenAutoFillInputFuture {
             inner: Box::pin(fut),
-8287
+        }
-8288
+    }
-8289
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryIdempotencyTokenAutoFillOutput
-8294
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8301
+                        }
-8302
+                    }
-8303
+    }
-8304
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryIdempotencyTokenAutoFillError
-8309
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_query_idempotency_token_auto_fill::ser_query_idempotency_token_auto_fill_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8319
+            }
-8320
+        }
-8321
+    }
-8322
+}
-8323
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OmitsSerializingEmptyListsInput`](crate::input::OmitsSerializingEmptyListsInput) using modelled bindings.
     pub struct OmitsSerializingEmptyListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsSerializingEmptyListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsSerializingEmptyListsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8329
+    }
-8330
+}
-8331
 impl std::future::Future for OmitsSerializingEmptyListsInputFuture {
     type Output = Result<
         crate::input::OmitsSerializingEmptyListsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8337
     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)
-8344
+    }
-8345
+}
-8346
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OmitsSerializingEmptyListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8355
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8359
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OmitsSerializingEmptyListsInputFuture;
-8363
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8371
+            }
             crate::protocol_serde::shape_omits_serializing_empty_lists::de_omits_serializing_empty_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         OmitsSerializingEmptyListsInputFuture {
             inner: Box::pin(fut),
-8382
+        }
-8383
+    }
-8384
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OmitsSerializingEmptyListsOutput
-8389
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8396
+                        }
-8397
+                    }
-8398
+    }
-8399
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OmitsSerializingEmptyListsError
-8404
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8414
+            }
-8415
+        }
-8416
+    }
-8417
+}
-8418
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OmitsNullSerializesEmptyStringInput`](crate::input::OmitsNullSerializesEmptyStringInput) using modelled bindings.
     pub struct OmitsNullSerializesEmptyStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsNullSerializesEmptyStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsNullSerializesEmptyStringInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8424
+    }
-8425
+}
-8426
 impl std::future::Future for OmitsNullSerializesEmptyStringInputFuture {
     type Output = Result<
         crate::input::OmitsNullSerializesEmptyStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8432
     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)
-8439
+    }
-8440
+}
-8441
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OmitsNullSerializesEmptyStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8450
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8454
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OmitsNullSerializesEmptyStringInputFuture;
-8458
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8466
+            }
             crate::protocol_serde::shape_omits_null_serializes_empty_string::de_omits_null_serializes_empty_string_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         OmitsNullSerializesEmptyStringInputFuture {
             inner: Box::pin(fut),
-8477
+        }
-8478
+    }
-8479
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OmitsNullSerializesEmptyStringOutput
-8484
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8491
+                        }
-8492
+                    }
-8493
+    }
-8494
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OmitsNullSerializesEmptyStringError
-8499
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_null_serializes_empty_string::ser_omits_null_serializes_empty_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8509
+            }
-8510
+        }
-8511
+    }
-8512
+}
-8513
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`IgnoreQueryParamsInResponseInput`](crate::input::IgnoreQueryParamsInResponseInput) using modelled bindings.
     pub struct IgnoreQueryParamsInResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::IgnoreQueryParamsInResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::IgnoreQueryParamsInResponseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8519
+    }
-8520
+}
-8521
 impl std::future::Future for IgnoreQueryParamsInResponseInputFuture {
     type Output = Result<
         crate::input::IgnoreQueryParamsInResponseInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8527
     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)
-8534
+    }
-8535
+}
-8536
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::IgnoreQueryParamsInResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8545
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8549
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = IgnoreQueryParamsInResponseInputFuture;
-8553
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8561
+            }
             crate::protocol_serde::shape_ignore_query_params_in_response::de_ignore_query_params_in_response_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         IgnoreQueryParamsInResponseInputFuture {
             inner: Box::pin(fut),
-8572
+        }
-8573
+    }
-8574
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::IgnoreQueryParamsInResponseOutput
-8579
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8586
+                        }
-8587
+                    }
-8588
+    }
-8589
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::IgnoreQueryParamsInResponseError
-8594
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_ignore_query_params_in_response::ser_ignore_query_params_in_response_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8604
+            }
-8605
+        }
-8606
+    }
-8607
+}
-8608
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ConstantAndVariableQueryStringInput`](crate::input::ConstantAndVariableQueryStringInput) using modelled bindings.
     pub struct ConstantAndVariableQueryStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantAndVariableQueryStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantAndVariableQueryStringInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8614
+    }
-8615
+}
-8616
 impl std::future::Future for ConstantAndVariableQueryStringInputFuture {
     type Output = Result<
         crate::input::ConstantAndVariableQueryStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8622
     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)
-8629
+    }
-8630
+}
-8631
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstantAndVariableQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8640
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8644
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstantAndVariableQueryStringInputFuture;
-8648
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8656
+            }
             crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         ConstantAndVariableQueryStringInputFuture {
             inner: Box::pin(fut),
-8667
+        }
-8668
+    }
-8669
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstantAndVariableQueryStringOutput
-8674
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8681
+                        }
-8682
+                    }
-8683
+    }
-8684
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ConstantAndVariableQueryStringError
-8689
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_and_variable_query_string::ser_constant_and_variable_query_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8699
+            }
-8700
+        }
-8701
+    }
-8702
+}
-8703
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ConstantQueryStringInput`](crate::input::ConstantQueryStringInput) using modelled bindings.
     pub struct ConstantQueryStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantQueryStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantQueryStringInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8709
+    }
-8710
+}
-8711
 impl std::future::Future for ConstantQueryStringInputFuture {
     type Output = Result<
         crate::input::ConstantQueryStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8717
     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)
-8724
+    }
-8725
+}
-8726
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstantQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8735
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8739
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstantQueryStringInputFuture;
-8743
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8751
+            }
             crate::protocol_serde::shape_constant_query_string::de_constant_query_string_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         ConstantQueryStringInputFuture {
             inner: Box::pin(fut),
-8762
+        }
-8763
+    }
-8764
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstantQueryStringOutput
-8769
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8776
+                        }
-8777
+                    }
-8778
+    }
-8779
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ConstantQueryStringError
-8784
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8794
+            }
-8795
+        }
-8796
+    }
-8797
+}
-8798
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`AllQueryStringTypesInput`](crate::input::AllQueryStringTypesInput) using modelled bindings.
     pub struct AllQueryStringTypesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::AllQueryStringTypesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::AllQueryStringTypesInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8804
+    }
-8805
+}
-8806
 impl std::future::Future for AllQueryStringTypesInputFuture {
     type Output = Result<
         crate::input::AllQueryStringTypesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8812
     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)
-8819
+    }
-8820
+}
-8821
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::AllQueryStringTypesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8830
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8834
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = AllQueryStringTypesInputFuture;
-8838
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8846
+            }
             crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         AllQueryStringTypesInputFuture {
             inner: Box::pin(fut),
-8857
+        }
-8858
+    }
-8859
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::AllQueryStringTypesOutput
-8864
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8871
+                        }
-8872
+                    }
-8873
+    }
-8874
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::AllQueryStringTypesError
-8879
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8889
+            }
-8890
+        }
-8891
+    }
-8892
+}
-8893
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithRegexLiteralInput`](crate::input::HttpRequestWithRegexLiteralInput) using modelled bindings.
     pub struct HttpRequestWithRegexLiteralInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithRegexLiteralInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithRegexLiteralInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8899
+    }
-8900
+}
-8901
 impl std::future::Future for HttpRequestWithRegexLiteralInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithRegexLiteralInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-8907
     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)
-8914
+    }
-8915
+}
-8916
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithRegexLiteralInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-8925
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-8929
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithRegexLiteralInputFuture;
-8933
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-8941
+            }
             crate::protocol_serde::shape_http_request_with_regex_literal::de_http_request_with_regex_literal_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpRequestWithRegexLiteralInputFuture {
             inner: Box::pin(fut),
-8952
+        }
-8953
+    }
-8954
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithRegexLiteralOutput
-8959
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8966
+                        }
-8967
+                    }
-8968
+    }
-8969
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithRegexLiteralError
-8974
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-8984
+            }
-8985
+        }
-8986
+    }
-8987
+}
-8988
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithFloatLabelsInput`](crate::input::HttpRequestWithFloatLabelsInput) using modelled bindings.
     pub struct HttpRequestWithFloatLabelsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithFloatLabelsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithFloatLabelsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8994
+    }
-8995
+}
-8996
 impl std::future::Future for HttpRequestWithFloatLabelsInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithFloatLabelsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9002
     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)
-9009
+    }
-9010
+}
-9011
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithFloatLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9020
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9024
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithFloatLabelsInputFuture;
-9028
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9036
+            }
             crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpRequestWithFloatLabelsInputFuture {
             inner: Box::pin(fut),
-9047
+        }
-9048
+    }
-9049
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithFloatLabelsOutput
-9054
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9061
+                        }
-9062
+                    }
-9063
+    }
-9064
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithFloatLabelsError
-9069
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9079
+            }
-9080
+        }
-9081
+    }
-9082
+}
-9083
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithGreedyLabelInPathInput`](crate::input::HttpRequestWithGreedyLabelInPathInput) using modelled bindings.
     pub struct HttpRequestWithGreedyLabelInPathInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithGreedyLabelInPathInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithGreedyLabelInPathInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9089
+    }
-9090
+}
-9091
 impl std::future::Future for HttpRequestWithGreedyLabelInPathInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithGreedyLabelInPathInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9097
     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)
-9104
+    }
-9105
+}
-9106
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithGreedyLabelInPathInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9115
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9119
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithGreedyLabelInPathInputFuture;
-9123
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9131
+            }
             crate::protocol_serde::shape_http_request_with_greedy_label_in_path::de_http_request_with_greedy_label_in_path_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpRequestWithGreedyLabelInPathInputFuture {
             inner: Box::pin(fut),
-9142
+        }
-9143
+    }
-9144
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithGreedyLabelInPathOutput
-9149
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9156
+                        }
-9157
+                    }
-9158
+    }
-9159
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithGreedyLabelInPathError
-9164
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9174
+            }
-9175
+        }
-9176
+    }
-9177
+}
-9178
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithLabelsAndTimestampFormatInput`](crate::input::HttpRequestWithLabelsAndTimestampFormatInput) using modelled bindings.
     pub struct HttpRequestWithLabelsAndTimestampFormatInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsAndTimestampFormatInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsAndTimestampFormatInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9184
+    }
-9185
+}
-9186
 impl std::future::Future for HttpRequestWithLabelsAndTimestampFormatInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithLabelsAndTimestampFormatInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9192
     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)
-9199
+    }
-9200
+}
-9201
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithLabelsAndTimestampFormatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9210
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9214
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithLabelsAndTimestampFormatInputFuture;
-9218
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9226
+            }
             crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::de_http_request_with_labels_and_timestamp_format_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpRequestWithLabelsAndTimestampFormatInputFuture {
             inner: Box::pin(fut),
-9237
+        }
-9238
+    }
-9239
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithLabelsAndTimestampFormatOutput
-9244
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9251
+                        }
-9252
+                    }
-9253
+    }
-9254
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithLabelsAndTimestampFormatError
-9259
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9269
+            }
-9270
+        }
-9271
+    }
-9272
+}
-9273
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithLabelsInput`](crate::input::HttpRequestWithLabelsInput) using modelled bindings.
     pub struct HttpRequestWithLabelsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9279
+    }
-9280
+}
-9281
 impl std::future::Future for HttpRequestWithLabelsInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithLabelsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9287
     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)
-9294
+    }
-9295
+}
-9296
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9305
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9309
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithLabelsInputFuture;
-9313
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9321
+            }
             crate::protocol_serde::shape_http_request_with_labels::de_http_request_with_labels_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         HttpRequestWithLabelsInputFuture {
             inner: Box::pin(fut),
-9332
+        }
-9333
+    }
-9334
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithLabelsOutput
-9339
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9346
+                        }
-9347
+                    }
-9348
+    }
-9349
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithLabelsError
-9354
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9364
+            }
-9365
+        }
-9366
+    }
-9367
+}
-9368
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MediaTypeHeaderInput`](crate::input::MediaTypeHeaderInput) using modelled bindings.
     pub struct MediaTypeHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MediaTypeHeaderInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MediaTypeHeaderInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9374
+    }
-9375
+}
-9376
 impl std::future::Future for MediaTypeHeaderInputFuture {
     type Output = Result<
         crate::input::MediaTypeHeaderInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9382
     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)
-9389
+    }
-9390
+}
-9391
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MediaTypeHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9400
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9404
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MediaTypeHeaderInputFuture;
-9408
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9416
+            }
             crate::protocol_serde::shape_media_type_header::de_media_type_header_http_request(
                 request,
-9419
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         MediaTypeHeaderInputFuture {
             inner: Box::pin(fut),
-9429
+        }
-9430
+    }
-9431
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MediaTypeHeaderOutput
-9436
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9445
+            }
-9446
+        }
-9447
+    }
-9448
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MediaTypeHeaderError
-9453
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_media_type_header::ser_media_type_header_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-9465
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9469
+            }
-9470
+        }
-9471
+    }
-9472
+}
-9473
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TimestampFormatHeadersInput`](crate::input::TimestampFormatHeadersInput) using modelled bindings.
     pub struct TimestampFormatHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TimestampFormatHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TimestampFormatHeadersInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9479
+    }
-9480
+}
-9481
 impl std::future::Future for TimestampFormatHeadersInputFuture {
     type Output = Result<
         crate::input::TimestampFormatHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9487
     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)
-9494
+    }
-9495
+}
-9496
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TimestampFormatHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9505
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9509
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TimestampFormatHeadersInputFuture;
-9513
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9521
+            }
             crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         TimestampFormatHeadersInputFuture {
             inner: Box::pin(fut),
-9532
+        }
-9533
+    }
-9534
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TimestampFormatHeadersOutput
-9539
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9546
+                        }
-9547
+                    }
-9548
+    }
-9549
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::TimestampFormatHeadersError
-9554
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_timestamp_format_headers::ser_timestamp_format_headers_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9564
+            }
-9565
+        }
-9566
+    }
-9567
+}
-9568
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullAndEmptyHeadersServerInput`](crate::input::NullAndEmptyHeadersServerInput) using modelled bindings.
     pub struct NullAndEmptyHeadersServerInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersServerInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersServerInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9574
+    }
-9575
+}
-9576
 impl std::future::Future for NullAndEmptyHeadersServerInputFuture {
     type Output = Result<
         crate::input::NullAndEmptyHeadersServerInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9582
     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)
-9589
+    }
-9590
+}
-9591
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullAndEmptyHeadersServerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9600
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9604
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullAndEmptyHeadersServerInputFuture;
-9608
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9616
+            }
             crate::protocol_serde::shape_null_and_empty_headers_server::de_null_and_empty_headers_server_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         NullAndEmptyHeadersServerInputFuture {
             inner: Box::pin(fut),
-9627
+        }
-9628
+    }
-9629
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullAndEmptyHeadersServerOutput
-9634
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9641
+                        }
-9642
+                    }
-9643
+    }
-9644
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::NullAndEmptyHeadersServerError
-9649
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_null_and_empty_headers_server::ser_null_and_empty_headers_server_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9659
+            }
-9660
+        }
-9661
+    }
-9662
+}
-9663
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullAndEmptyHeadersClientInput`](crate::input::NullAndEmptyHeadersClientInput) using modelled bindings.
     pub struct NullAndEmptyHeadersClientInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersClientInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersClientInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9669
+    }
-9670
+}
-9671
 impl std::future::Future for NullAndEmptyHeadersClientInputFuture {
     type Output = Result<
         crate::input::NullAndEmptyHeadersClientInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9677
     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)
-9684
+    }
-9685
+}
-9686
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullAndEmptyHeadersClientInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9695
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9699
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullAndEmptyHeadersClientInputFuture;
-9703
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9711
+            }
             crate::protocol_serde::shape_null_and_empty_headers_client::de_null_and_empty_headers_client_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         NullAndEmptyHeadersClientInputFuture {
             inner: Box::pin(fut),
-9722
+        }
-9723
+    }
-9724
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullAndEmptyHeadersClientOutput
-9729
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9736
+                        }
-9737
+                    }
-9738
+    }
-9739
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::NullAndEmptyHeadersClientError
-9744
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_null_and_empty_headers_client::ser_null_and_empty_headers_client_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9754
+            }
-9755
+        }
-9756
+    }
-9757
+}
-9758
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`InputAndOutputWithHeadersInput`](crate::input::InputAndOutputWithHeadersInput) using modelled bindings.
     pub struct InputAndOutputWithHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::InputAndOutputWithHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::InputAndOutputWithHeadersInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9764
+    }
-9765
+}
-9766
 impl std::future::Future for InputAndOutputWithHeadersInputFuture {
     type Output = Result<
         crate::input::InputAndOutputWithHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9772
     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)
-9779
+    }
-9780
+}
-9781
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::InputAndOutputWithHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9790
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9794
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = InputAndOutputWithHeadersInputFuture;
-9798
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9806
+            }
             crate::protocol_serde::shape_input_and_output_with_headers::de_input_and_output_with_headers_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         InputAndOutputWithHeadersInputFuture {
             inner: Box::pin(fut),
-9817
+        }
-9818
+    }
-9819
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::InputAndOutputWithHeadersOutput
-9824
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9831
+                        }
-9832
+                    }
-9833
+    }
-9834
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::InputAndOutputWithHeadersError
-9839
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9849
+            }
-9850
+        }
-9851
+    }
-9852
+}
-9853
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`UnitInputAndOutputInput`](crate::input::UnitInputAndOutputInput) using modelled bindings.
     pub struct UnitInputAndOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::UnitInputAndOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::UnitInputAndOutputInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9859
+    }
-9860
+}
-9861
 impl std::future::Future for UnitInputAndOutputInputFuture {
     type Output = Result<
         crate::input::UnitInputAndOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9867
     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)
-9874
+    }
-9875
+}
-9876
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::UnitInputAndOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9885
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9889
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = UnitInputAndOutputInputFuture;
-9893
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9901
+            }
             crate::protocol_serde::shape_unit_input_and_output::de_unit_input_and_output_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         UnitInputAndOutputInputFuture {
             inner: Box::pin(fut),
-9912
+        }
-9913
+    }
-9914
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::UnitInputAndOutputOutput
-9919
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9926
+                        }
-9927
+                    }
-9928
+    }
-9929
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::UnitInputAndOutputError
-9934
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_unit_input_and_output::ser_unit_input_and_output_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-9944
+            }
-9945
+        }
-9946
+    }
-9947
+}
-9948
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EmptyInputAndEmptyOutputInput`](crate::input::EmptyInputAndEmptyOutputInput) using modelled bindings.
     pub struct EmptyInputAndEmptyOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyInputAndEmptyOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyInputAndEmptyOutputInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-9954
+    }
-9955
+}
-9956
 impl std::future::Future for EmptyInputAndEmptyOutputInputFuture {
     type Output = Result<
         crate::input::EmptyInputAndEmptyOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-9962
     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)
-9969
+    }
-9970
+}
-9971
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyInputAndEmptyOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-9980
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-9984
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyInputAndEmptyOutputInputFuture;
-9988
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-9996
+            }
             crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         EmptyInputAndEmptyOutputInputFuture {
             inner: Box::pin(fut),
-10007
+        }
-10008
+    }
-10009
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyInputAndEmptyOutputOutput
-10014
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10021
+                        }
-10022
+                    }
-10023
+    }
-10024
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EmptyInputAndEmptyOutputError
-10029
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_input_and_empty_output::ser_empty_input_and_empty_output_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10039
+            }
-10040
+        }
-10041
+    }
-10042
+}
-10043
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NoInputAndOutputInput`](crate::input::NoInputAndOutputInput) using modelled bindings.
     pub struct NoInputAndOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NoInputAndOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NoInputAndOutputInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-10049
+    }
-10050
+}
-10051
 impl std::future::Future for NoInputAndOutputInputFuture {
     type Output = Result<
         crate::input::NoInputAndOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-10057
     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)
-10064
+    }
-10065
+}
-10066
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NoInputAndOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-10075
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-10079
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NoInputAndOutputInputFuture;
-10083
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-10091
+            }
             crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_request(
                 request,
-10094
+            )
             .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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         NoInputAndOutputInputFuture {
             inner: Box::pin(fut),
-10104
+        }
-10105
+    }
-10106
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NoInputAndOutputOutput
-10111
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10118
+                        }
-10119
+                    }
-10120
+    }
-10121
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::NoInputAndOutputError
-10126
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                     ::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(
                         self.name(),
                     ),
                 );
                 response
-10138
+            }
             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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10142
+            }
-10143
+        }
-10144
+    }
-10145
+}
-10146
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NoInputAndNoOutputInput`](crate::input::NoInputAndNoOutputInput) using modelled bindings.
     pub struct NoInputAndNoOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NoInputAndNoOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NoInputAndNoOutputInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-10152
+    }
-10153
+}
-10154
 impl std::future::Future for NoInputAndNoOutputInputFuture {
     type Output = Result<
         crate::input::NoInputAndNoOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-10160
     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)
-10167
+    }
-10168
+}
-10169
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NoInputAndNoOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-10178
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-10182
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NoInputAndNoOutputInputFuture;
-10186
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-10194
+            }
             crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_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,
--
+                )
             },
         );
         let fut = fut.map_err(|e: ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                         ::tracing::debug!(error = %e, "failed to deserialize request");
                         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e)
                     });
         NoInputAndNoOutputInputFuture {
             inner: Box::pin(fut),
-10205
+        }
-10206
+    }
-10207
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NoInputAndNoOutputOutput
-10212
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_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))
                             ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10219
+                        }
-10220
+                    }
-10221
+    }
-10222
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::NoInputAndNoOutputError
-10227
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(::aws_smithy_legacy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 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))
                 ::aws_smithy_legacy_http_server::response::IntoResponse::<::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-10237
+            }
-10238
+        }
-10239
+    }
-10240
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35