Server Test

Server Test

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/rest_json_extras-http0x/rust-server-codegen/src/mimes.rs

@@ -0,1 +0,14 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub(crate) static CONTENT_TYPE_APPLICATION_JSON: std::sync::LazyLock<::mime::Mime> =
     std::sync::LazyLock::new(|| {
         "application/json"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
-+
 pub(crate) static CONTENT_TYPE_TEXT_PLAIN: std::sync::LazyLock<::mime::Mime> =
     std::sync::LazyLock::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });

tmp-codegen-diff/codegen-server-test/rest_json_extras-http0x/rust-server-codegen/src/model.rs

@@ -0,1 +0,386 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct EmptyStruct {}
 impl EmptyStruct {
     /// Creates a new builder-style object to manufacture [`EmptyStruct`](crate::model::EmptyStruct).
     pub fn builder() -> crate::model::empty_struct::Builder {
         crate::model::empty_struct::Builder::default()
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub enum SingleElementUnion {
     #[allow(missing_docs)] // documentation missing in model
     A(::std::string::String),
-+
+}
 impl SingleElementUnion {
     #[allow(irrefutable_let_patterns)]
     /// Tries to convert the enum instance into [`A`](crate::model::SingleElementUnion::A), extracting the inner [`String`](::std::string::String).
     /// Returns `Err(&Self)` if it can't be converted.
     pub fn as_a(&self) -> ::std::result::Result<&::std::string::String, &Self> {
         if let SingleElementUnion::A(val) = &self {
             ::std::result::Result::Ok(val)
         } else {
             ::std::result::Result::Err(self)
-+
+        }
-+
+    }
     /// Returns true if this is a [`A`](crate::model::SingleElementUnion::A).
     pub fn is_a(&self) -> bool {
         self.as_a().is_ok()
-+
+    }
-+
+}
-+
 /// Describes one specific validation failure for an input member.
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub path: ::std::string::String,
     /// A detailed description of the validation failure.
     pub message: ::std::string::String,
-+
+}
 impl ValidationExceptionField {
     /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     pub fn path(&self) -> &str {
         use std::ops::Deref;
         self.path.deref()
-+
+    }
     /// A detailed description of the validation failure.
     pub fn message(&self) -> &str {
         use std::ops::Deref;
         self.message.deref()
-+
+    }
-+
+}
 impl ValidationExceptionField {
     /// Creates a new builder-style object to manufacture [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     pub fn builder() -> crate::model::validation_exception_field::Builder {
         crate::model::validation_exception_field::Builder::default()
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum EnumWithEscapedChars {
     /// this needs#tobe escaped
     HasQuotes,
     #[allow(missing_docs)] // documentation missing in model
     Normal,
-+
+}
 /// See [`EnumWithEscapedChars`](crate::model::EnumWithEscapedChars).
 pub mod enum_with_escaped_chars {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#EnumWithEscapedChars' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#
-+
+            )
-+
+        }
-+
+    }
-+
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [has"quotes, normal]"#,
                     &path
                 ),
                 path,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::TryFrom<&str> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "has\"quotes" => Ok(EnumWithEscapedChars::HasQuotes),
             "normal" => Ok(EnumWithEscapedChars::Normal),
             _ => Err(crate::model::enum_with_escaped_chars::ConstraintViolation(
                 s.to_owned(),
             )),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::TryFrom<::std::string::String> for EnumWithEscapedChars {
     type Error = crate::model::enum_with_escaped_chars::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-+
+    {
         s.as_str().try_into()
-+
+    }
-+
+}
 impl std::str::FromStr for EnumWithEscapedChars {
     type Err = crate::model::enum_with_escaped_chars::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-+
+    }
-+
+}
 impl EnumWithEscapedChars {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             EnumWithEscapedChars::HasQuotes => "has\"quotes",
             EnumWithEscapedChars::Normal => "normal",
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["has\"quotes", "normal"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for EnumWithEscapedChars {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for EnumWithEscapedChars {
     type Unconstrained = ::std::string::String;
-+
+}
-+
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::EnumWithEscapedChars>
-+
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-+
+    }
-+
+}
-+
 #[allow(missing_docs)] // documentation missing in model
 #[derive(
     ::std::clone::Clone,
     ::std::cmp::Eq,
     ::std::cmp::Ord,
     ::std::cmp::PartialEq,
     ::std::cmp::PartialOrd,
     ::std::fmt::Debug,
     ::std::hash::Hash,
 )]
 pub enum StringEnum {
     #[allow(missing_docs)] // documentation missing in model
     V,
-+
+}
 /// See [`StringEnum`](crate::model::StringEnum).
 pub mod string_enum {
     #[derive(Debug, PartialEq)]
     pub struct ConstraintViolation(pub(crate) ::std::string::String);
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
                 r#"Value provided for 'aws.protocoltests.restjson#StringEnum' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#
-+
+            )
-+
+        }
-+
+    }
-+
     impl ::std::error::Error for ConstraintViolation {}
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             crate::model::ValidationExceptionField {
                 message: format!(
                     r#"Value at '{}' failed to satisfy constraint: Member must satisfy enum value set: [enumvalue]"#,
                     &path
                 ),
                 path,
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::TryFrom<&str> for StringEnum {
     type Error = crate::model::string_enum::ConstraintViolation;
     fn try_from(
         s: &str,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<&str>>::Error> {
         match s {
             "enumvalue" => Ok(StringEnum::V),
             _ => Err(crate::model::string_enum::ConstraintViolation(s.to_owned())),
-+
+        }
-+
+    }
-+
+}
 impl ::std::convert::TryFrom<::std::string::String> for StringEnum {
     type Error = crate::model::string_enum::ConstraintViolation;
     fn try_from(
         s: ::std::string::String,
     ) -> ::std::result::Result<Self, <Self as ::std::convert::TryFrom<::std::string::String>>::Error>
-+
+    {
         s.as_str().try_into()
-+
+    }
-+
+}
 impl std::str::FromStr for StringEnum {
     type Err = crate::model::string_enum::ConstraintViolation;
     fn from_str(s: &str) -> std::result::Result<Self, <Self as std::str::FromStr>::Err> {
         Self::try_from(s)
-+
+    }
-+
+}
 impl StringEnum {
     /// Returns the `&str` value of the enum member.
     pub fn as_str(&self) -> &str {
         match self {
             StringEnum::V => "enumvalue",
-+
+        }
-+
+    }
     /// Returns all the `&str` representations of the enum members.
     pub const fn values() -> &'static [&'static str] {
         &["enumvalue"]
-+
+    }
-+
+}
 impl ::std::convert::AsRef<str> for StringEnum {
     fn as_ref(&self) -> &str {
         self.as_str()
-+
+    }
-+
+}
 impl crate::constrained::Constrained for StringEnum {
     type Unconstrained = ::std::string::String;
-+
+}
-+
 impl ::std::convert::From<::std::string::String>
     for crate::constrained::MaybeConstrained<crate::model::StringEnum>
-+
+{
     fn from(value: ::std::string::String) -> Self {
         Self::Unconstrained(value)
-+
+    }
-+
+}
 /// See [`EmptyStruct`](crate::model::EmptyStruct).
 pub mod empty_struct {
-+
     impl ::std::convert::From<Builder> for crate::model::EmptyStruct {
         fn from(builder: Builder) -> Self {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`EmptyStruct`](crate::model::EmptyStruct).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     impl Builder {
         /// Consumes the builder and constructs a [`EmptyStruct`](crate::model::EmptyStruct).
         pub fn build(self) -> crate::model::EmptyStruct {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(self) -> crate::model::EmptyStruct {
             crate::model::EmptyStruct {}
-+
+        }
-+
+    }
-+
+}
 /// See [`ValidationExceptionField`](crate::model::ValidationExceptionField).
 pub mod validation_exception_field {
-+
     #[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 enum ConstraintViolation {
         /// `path` was not provided but it is required when building `ValidationExceptionField`.
         MissingPath,
         /// `message` was not provided but it is required when building `ValidationExceptionField`.
         MissingMessage,
-+
+    }
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 ConstraintViolation::MissingPath => write!(f, "`path` was not provided but it is required when building `ValidationExceptionField`"),
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationExceptionField`"),
-+
+            }
-+
+        }
-+
+    }
     impl ::std::error::Error for ConstraintViolation {}
     impl ::std::convert::TryFrom<Builder> for crate::model::ValidationExceptionField {
         type Error = ConstraintViolation;
-+
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-+
+        }
-+
+    }
     /// A builder for [`ValidationExceptionField`](crate::model::ValidationExceptionField).
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {
         pub(crate) path: ::std::option::Option<::std::string::String>,
         pub(crate) message: ::std::option::Option<::std::string::String>,
-+
+    }
     impl Builder {
         /// A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
         pub fn path(mut self, input: ::std::string::String) -> Self {
             self.path = Some(input);
             self
-+
+        }
         /// A detailed description of the validation failure.
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             self
-+
+        }
         /// Consumes the builder and constructs a [`ValidationExceptionField`](crate::model::ValidationExceptionField).
         ///
         /// The builder fails to construct a [`ValidationExceptionField`](crate::model::ValidationExceptionField) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         pub fn build(self) -> Result<crate::model::ValidationExceptionField, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-+
+        }
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::model::ValidationExceptionField, ConstraintViolation> {
             Ok(crate::model::ValidationExceptionField {
                 path: self.path.ok_or(ConstraintViolation::MissingPath)?,
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
-+
+        }
-+
+    }
-+
+}
 pub mod map_with_enum_key {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, PartialEq)]
     pub enum ConstraintViolation {
         #[doc(hidden)]
         Key(crate::model::string_enum::ConstraintViolation),
-+
+    }
-+
     impl ::std::fmt::Display for ConstraintViolation {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             match self {
                 Self::Key(key_constraint_violation) => write!(f, "{}", key_constraint_violation),
-+
+            }
-+
+        }
-+
+    }
-+
     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 {
                 Self::Key(key_constraint_violation) => {
                     key_constraint_violation.as_validation_exception_field(path)
-+
+                }
-+
+            }
-+
+        }
-+
+    }
-+
+}

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

@@ -0,1 +0,1930 @@

 // 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
     /// [`HttpQueryParamsOnlyOperationInput`](crate::input::HttpQueryParamsOnlyOperationInput) using modelled bindings.
     pub struct HttpQueryParamsOnlyOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpQueryParamsOnlyOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for HttpQueryParamsOnlyOperationInputFuture {
     type Output = Result<
         crate::input::HttpQueryParamsOnlyOperationInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpQueryParamsOnlyOperationInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpQueryParamsOnlyOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_http_query_params_only_operation::de_http_query_params_only_operation_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         HttpQueryParamsOnlyOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpQueryParamsOnlyOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::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))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpQueryParamsOnlyOperationError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_http_query_params_only_operation::ser_http_query_params_only_operation_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_query_params_only_operation_test {
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::HttpQueryParamsOnlyOperationError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::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_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for QueryPrecedenceInputFuture {
     type Output = Result<
         crate::input::QueryPrecedenceInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             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_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),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
-+
+{
     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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::QueryPrecedenceError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_error(&self)
-+
+        {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod query_precedence_test {
-+
     /// Servers put all query params in map
     /// Test ID: RestJsonServersPutAllQueryParamsInMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_servers_put_all_query_params_in_map_request() {
         #[allow(unused_mut)]
         let mut http_request = ::http::Request::builder()
             .uri("/Precedence")
             .method("POST")
             .body(::aws_smithy_legacy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     "".as_bytes(),
                     ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 )),
             ))
             .unwrap();
         *http_request.uri_mut() = "/Precedence?bar=named&qux=fromMap".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
                 .query_precedence(move |input: crate::input::QueryPrecedenceInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::QueryPrecedenceInput {
                                 foo: ::std::option::Option::Some("named".to_owned()),
                                 baz: ::std::option::Option::Some({
                                     let mut ret = ::std::collections::HashMap::new();
                                     ret.insert("bar".to_owned(), "named".to_owned());
                                     ret.insert("qux".to_owned(), "fromMap".to_owned());
                                     ret
                                 }),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let output = crate::output::QueryPrecedenceOutput {};
                             Ok(output)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-+
+                    }
                 })
                 .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-+
+    }
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::QueryPrecedenceError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EmptyStructWithContentOnWireOpInput`](crate::input::EmptyStructWithContentOnWireOpInput) using modelled bindings.
     pub struct EmptyStructWithContentOnWireOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyStructWithContentOnWireOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for EmptyStructWithContentOnWireOpInputFuture {
     type Output = Result<
         crate::input::EmptyStructWithContentOnWireOpInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyStructWithContentOnWireOpInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyStructWithContentOnWireOpInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         EmptyStructWithContentOnWireOpInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyStructWithContentOnWireOpOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_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))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EmptyStructWithContentOnWireOpError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_struct_with_content_on_wire_op_test {
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::EmptyStructWithContentOnWireOpError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`CaseInsensitiveErrorOperationInput`](crate::input::CaseInsensitiveErrorOperationInput) using modelled bindings.
     pub struct CaseInsensitiveErrorOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::CaseInsensitiveErrorOperationInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for CaseInsensitiveErrorOperationInputFuture {
     type Output = Result<
         crate::input::CaseInsensitiveErrorOperationInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CaseInsensitiveErrorOperationInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CaseInsensitiveErrorOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         CaseInsensitiveErrorOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CaseInsensitiveErrorOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_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))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::CaseInsensitiveErrorOperationError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod case_insensitive_error_operation_test {
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::CaseInsensitiveErrorOperationError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullInNonSparseInput`](crate::input::NullInNonSparseInput) using modelled bindings.
     pub struct NullInNonSparseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullInNonSparseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for NullInNonSparseInputFuture {
     type Output = Result<
         crate::input::NullInNonSparseInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullInNonSparseInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullInNonSparseInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(
                 request,
-+
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         NullInNonSparseInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullInNonSparseOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::NullInNonSparseError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod null_in_non_sparse_test {
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::NullInNonSparseError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EscapedStringValuesInput`](crate::input::EscapedStringValuesInput) using modelled bindings.
     pub struct EscapedStringValuesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EscapedStringValuesInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for EscapedStringValuesInputFuture {
     type Output = Result<
         crate::input::EscapedStringValuesInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EscapedStringValuesInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EscapedStringValuesInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         EscapedStringValuesInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EscapedStringValuesOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_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))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EscapedStringValuesError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod escaped_string_values_test {
-+
     /// Test ID: EscapedStringValuesRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn escaped_string_values_request_request() {
         #[allow(unused_mut)]
         let mut http_request = ::http::Request::builder()
             .uri("/escaped-string-values")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_legacy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}".as_bytes(),
                     ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 )),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
                 .escaped_string_values(move |input: crate::input::EscapedStringValuesInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EscapedStringValuesInput {
                                 r#enum: ::std::option::Option::Some(
                                     "has\"quotes"
                                         .parse::<crate::model::EnumWithEscapedChars>()
                                         .expect("static value validated to member"),
                                 ),
                                 some_string: ::std::option::Option::Some("test".to_owned()),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let output = crate::output::EscapedStringValuesOutput {
                                 r#enum: ::std::option::Option::None,
                                 some_string: ::std::option::Option::None,
                             };
                             Ok(output)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-+
+                    }
                 })
                 .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-+
+    }
     /// Test ID: EscapedStringValuesResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn escaped_string_values_response_response() {
         let output = crate::output::EscapedStringValuesOutput {
             r#enum: ::std::option::Option::Some(
                 "has\"quotes"
                     .parse::<crate::model::EnumWithEscapedChars>()
                     .expect("static value validated to member"),
             ),
             some_string: ::std::option::Option::Some("test".to_owned()),
         };
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{\"enum\":\"has\\\"quotes\",\"also\\\"has\\\"quotes\":\"test\"}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::EscapedStringValuesError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PrimitiveIntOpInput`](crate::input::PrimitiveIntOpInput) using modelled bindings.
     pub struct PrimitiveIntOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for PrimitiveIntOpInputFuture {
     type Output = Result<
         crate::input::PrimitiveIntOpInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntOpInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntOpInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_primitive_int_op::de_primitive_int_op_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         PrimitiveIntOpInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntOpOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_op::ser_primitive_int_op_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PrimitiveIntOpError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_op::ser_primitive_int_op_http_error(&self)
-+
+        {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod primitive_int_op_test {
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::PrimitiveIntOpError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MapWithEnumKeyOpInput`](crate::input::MapWithEnumKeyOpInput) using modelled bindings.
     pub struct MapWithEnumKeyOpInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MapWithEnumKeyOpInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MapWithEnumKeyOpInputFuture {
     type Output = Result<
         crate::input::MapWithEnumKeyOpInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MapWithEnumKeyOpInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MapWithEnumKeyOpInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_request(
                 request,
-+
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         MapWithEnumKeyOpInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MapWithEnumKeyOpOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_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))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MapWithEnumKeyOpError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod map_with_enum_key_op_test {
-+
     /// Test ID: MapWithEnumKeyRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_request_request() {
         #[allow(unused_mut)]
         let mut http_request = ::http::Request::builder()
             .uri("/map-with-enum-key")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_legacy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     "{\"map\":{\"enumvalue\":\"something\"}}".as_bytes(),
                     ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 )),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
                 .map_with_enum_key_op(move |input: crate::input::MapWithEnumKeyOpInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::MapWithEnumKeyOpInput {
                                 map: ::std::option::Option::Some({
                                     let mut ret = ::std::collections::HashMap::new();
                                     ret.insert(
                                         "enumvalue"
                                             .parse::<crate::model::StringEnum>()
                                             .expect("static value validated to member"),
                                         "something".to_owned(),
                                     );
                                     ret
                                 }),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let output = crate::output::MapWithEnumKeyOpOutput {
                                 map: ::std::option::Option::None,
                             };
                             Ok(output)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-+
+                    }
                 })
                 .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-+
+    }
     /// Test ID: MapWithEnumKeyResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn map_with_enum_key_response_response() {
         let output = crate::output::MapWithEnumKeyOpOutput {
             map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "enumvalue"
                         .parse::<crate::model::StringEnum>()
                         .expect("static value validated to member"),
                     "something".to_owned(),
                 );
                 ret
             }),
         };
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{\"map\":{\"enumvalue\":\"something\"}}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::MapWithEnumKeyOpError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StatusResponseInput`](crate::input::StatusResponseInput) using modelled bindings.
     pub struct StatusResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StatusResponseInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for StatusResponseInputFuture {
     type Output = Result<
         crate::input::StatusResponseInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StatusResponseInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StatusResponseInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_status_response::de_status_response_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         StatusResponseInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StatusResponseOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_response(self)
-+
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StatusResponseError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod status_response_test {
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::StatusResponseError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EnumQueryInput`](crate::input::EnumQueryInput) using modelled bindings.
     pub struct EnumQueryInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EnumQueryInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for EnumQueryInputFuture {
     type Output = Result<
         crate::input::EnumQueryInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EnumQueryInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EnumQueryInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(|e: ::aws_smithy_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)
                     });
         EnumQueryInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EnumQueryOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EnumQueryError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod enum_query_test {
-+
     /// Test ID: EnumQueryRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn enum_query_request_request() {
         #[allow(unused_mut)]
         let mut http_request = ::http::Request::builder()
             .uri("/foo/enumvalue")
             .method("GET")
             .body(::aws_smithy_legacy_http_server::body::Body::empty())
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
                 .enum_query(move |input: crate::input::EnumQueryInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EnumQueryInput {
                                 r#enum: "enumvalue"
                                     .parse::<crate::model::StringEnum>()
                                     .expect("static value validated to member"),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let output = crate::output::EnumQueryOutput {};
                             Ok(output)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-+
+                    }
                 })
                 .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-+
+    }
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::EnumQueryError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PrimitiveIntHeaderInput`](crate::input::PrimitiveIntHeaderInput) using modelled bindings.
     pub struct PrimitiveIntHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PrimitiveIntHeaderInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for PrimitiveIntHeaderInputFuture {
     type Output = Result<
         crate::input::PrimitiveIntHeaderInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntHeaderInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntHeaderInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_primitive_int_header::de_primitive_int_header_http_request(
                 request,
-+
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         PrimitiveIntHeaderInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntHeaderOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_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))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::PrimitiveIntHeaderError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod primitive_int_header_test {
-+
     /// Test ID: DeserPrimitiveHeader
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_primitive_header_response() {
         let output = crate::output::PrimitiveIntHeaderOutput { field: 123 };
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("x-field", "123")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-+
+    }
     /// Test ID: DeserPrimitiveHeaderMissing
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn deser_primitive_header_missing_response() {
         let output = crate::output::PrimitiveIntHeaderOutput { field: 0 };
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
-+
+    }
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::PrimitiveIntHeaderError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StringPayloadInput`](crate::input::StringPayloadInput) using modelled bindings.
     pub struct StringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StringPayloadInput, ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for StringPayloadInputFuture {
     type Output = Result<
         crate::input::StringPayloadInput,
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-+
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-+
+    }
-+
+}
-+
 impl<B>
     ::aws_smithy_legacy_http_server::request::FromRequest<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StringPayloadInput
 where
     B: ::aws_smithy_legacy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_legacy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection =
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StringPayloadInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_legacy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_TEXT_PLAIN,
             ) {
                 return Err(::aws_smithy_legacy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_string_payload::de_string_payload_http_request(request)
                 .await
         };
         use ::futures_util::future::TryFutureExt;
         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)
                     });
         StringPayloadInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StringPayloadOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_legacy_http_server::response::IntoResponse<
         ::aws_smithy_legacy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::StringPayloadError
-+
+{
     fn into_response(self) -> ::aws_smithy_legacy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_error(&self) {
             Ok(mut response) => {
                 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_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))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod string_payload_test {
-+
     /// Test ID: StringPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn string_payload_request() {
         #[allow(unused_mut)]
         let mut http_request = ::http::Request::builder()
             .uri("/StringPayload")
             .method("POST")
             .header("Content-Type", "text/plain")
             .body(::aws_smithy_legacy_http_server::body::Body::from(
                 ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                     "rawstring".as_bytes(),
                     ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 )),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonExtrasConfig::builder().build();
         let service =
             crate::service::RestJsonExtras::builder::<::hyper::body::Body, _, _, _>(config)
                 .string_payload(move |input: crate::input::StringPayloadInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StringPayloadInput {
                                 payload: ::std::option::Option::Some("rawstring".to_owned()),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let output = crate::output::StringPayloadOutput {
                                 payload: ::std::option::Option::None,
                             };
                             Ok(output)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-+
+                    }
                 })
                 .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to make an HTTP request");
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-+
+    }
-+
     /// Upper case error modeled lower case.
     /// Test ID: ServiceLevelErrorServer
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn service_level_error_server_response() {
         let output = crate::error::ExtraError {};
         let output = crate::error::StringPayloadError::ExtraError(output);
         use ::aws_smithy_legacy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             ::http::StatusCode::from_u16(500).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("X-Amzn-Errortype", "ExtraError")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{}",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}

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 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207