Server Test

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

@@ -1,1 +41227,42040 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[cfg(test)]
 const CONTENT_TYPE_PUTWITHCONTENTENCODING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput) using modelled bindings.
     pub struct PutWithContentEncodingInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PutWithContentEncodingInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for PutWithContentEncodingInputFuture {
     type Output = Result<
         crate::input::PutWithContentEncodingInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PutWithContentEncodingOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_FRACTIONALSECONDS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`FractionalSecondsInput`](crate::input::FractionalSecondsInput) using modelled bindings.
     pub struct FractionalSecondsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::FractionalSecondsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for FractionalSecondsInputFuture {
     type Output = Result<
         crate::input::FractionalSecondsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FRACTIONALSECONDS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         FractionalSecondsInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::FractionalSecondsOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_DATETIMEOFFSETS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DatetimeOffsetsInput`](crate::input::DatetimeOffsetsInput) using modelled bindings.
     pub struct DatetimeOffsetsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DatetimeOffsetsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for DatetimeOffsetsInputFuture {
     type Output = Result<
         crate::input::DatetimeOffsetsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DatetimeOffsetsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DatetimeOffsetsInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DATETIMEOFFSETS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         DatetimeOffsetsInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DatetimeOffsetsOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_TESTNOPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestNoPayloadInput`](crate::input::TestNoPayloadInput) using modelled bindings.
     pub struct TestNoPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for TestNoPayloadInputFuture {
     type Output = Result<
         crate::input::TestNoPayloadInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestNoPayloadInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTNOPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_test_no_payload::de_test_no_payload_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         TestNoPayloadInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestNoPayloadOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_no_payload::ser_test_no_payload_http_response(self)
-+
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_all_query_string_types_test {
     /// Serializes query string parameters with all supported types
     /// Test ID: RestJsonAllQueryStringTypes
 #[cfg(test)]
 mod test_no_payload_test {
-+
     /// Serializes a GET request with no modeled body
     /// Test ID: RestJsonHttpWithNoModeledBody
     #[::tokio::test]
     async fn rest_json_all_query_string_types_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_no_modeled_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .uri("/no_payload")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?String=Hello%20there&StringList=a&StringList=b&StringList=c&StringSet=a&StringSet=b&StringSet=c&Byte=1&Short=2&Integer=3&IntegerList=1&IntegerList=2&IntegerList=3&IntegerSet=1&IntegerSet=2&IntegerSet=3&Long=4&Float=1.1&Double=1.1&DoubleList=1.1&DoubleList=2.1&DoubleList=3.1&Boolean=true&BooleanList=true&BooleanList=false&BooleanList=true&Timestamp=1970-01-01T00%3A00%3A01Z&TimestampList=1970-01-01T00%3A00%3A01Z&TimestampList=1970-01-01T00%3A00%3A02Z&TimestampList=1970-01-01T00%3A00%3A03Z&Enum=Foo&EnumList=Foo&EnumList=Baz&EnumList=Bar&IntegerEnum=1&IntegerEnumList=1&IntegerEnumList=2&IntegerEnumList=3".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
             .test_no_payload(move |input: crate::input::TestNoPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_string: ::std::option::Option::Some("Hello there".to_owned()),
                             query_string_list: ::std::option::Option::Some(vec![
                                 "a".to_owned(),
                                 "b".to_owned(),
                                 "c".to_owned(),
                             ]),
                             query_string_set: ::std::option::Option::Some(
                                 vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]
                                     .try_into()
                                     .expect("this is only used in tests"),
                             ),
                             query_byte: ::std::option::Option::Some(1),
                             query_short: ::std::option::Option::Some(2),
                             query_integer: ::std::option::Option::Some(3),
                             query_integer_list: ::std::option::Option::Some(vec![1, 2, 3]),
                             query_integer_set: ::std::option::Option::Some(
                                 vec![1, 2, 3]
                                     .try_into()
                                     .expect("this is only used in tests"),
                             ),
                             query_long: ::std::option::Option::Some(4),
                             query_float: ::std::option::Option::Some(1.1_f32),
                             query_double: ::std::option::Option::Some(1.1_f64),
                             query_double_list: ::std::option::Option::Some(vec![
 .1_f64, 2.1_f64, 3.1_f64,
                             ]),
                             query_boolean: ::std::option::Option::Some(true),
                             query_boolean_list: ::std::option::Option::Some(vec![
                                 true, false, true,
                             ]),
                             query_timestamp: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64),
                             ),
                             query_timestamp_list: ::std::option::Option::Some(vec![
                                 ::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64),
                                 ::aws_smithy_types::DateTime::from_fractional_secs(2, 0_f64),
                                 ::aws_smithy_types::DateTime::from_fractional_secs(3, 0_f64),
                             ]),
                             query_enum: ::std::option::Option::Some(
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             query_enum_list: ::std::option::Option::Some(vec![
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "Baz"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "Bar"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ]),
                             query_integer_enum: ::std::option::Option::Some(1),
                             query_integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("String".to_owned(), vec!["Hello there".to_owned()]);
                                 ret.insert(
                                     "StringList".to_owned(),
                                     vec!["a".to_owned(), "b".to_owned(), "c".to_owned()],
                                 );
                                 ret.insert(
                                     "StringSet".to_owned(),
                                     vec!["a".to_owned(), "b".to_owned(), "c".to_owned()],
                                 );
                                 ret.insert("Byte".to_owned(), vec!["1".to_owned()]);
                                 ret.insert("Short".to_owned(), vec!["2".to_owned()]);
                                 ret.insert("Integer".to_owned(), vec!["3".to_owned()]);
                                 ret.insert(
                                     "IntegerList".to_owned(),
                                     vec!["1".to_owned(), "2".to_owned(), "3".to_owned()],
                                 );
                                 ret.insert(
                                     "IntegerSet".to_owned(),
                                     vec!["1".to_owned(), "2".to_owned(), "3".to_owned()],
                                 );
                                 ret.insert("Long".to_owned(), vec!["4".to_owned()]);
                                 ret.insert("Float".to_owned(), vec!["1.1".to_owned()]);
                                 ret.insert("Double".to_owned(), vec!["1.1".to_owned()]);
                                 ret.insert(
                                     "DoubleList".to_owned(),
                                     vec!["1.1".to_owned(), "2.1".to_owned(), "3.1".to_owned()],
                                 );
                                 ret.insert("Boolean".to_owned(), vec!["true".to_owned()]);
                                 ret.insert(
                                     "BooleanList".to_owned(),
                                     vec!["true".to_owned(), "false".to_owned(), "true".to_owned()],
                                 );
                                 ret.insert(
                                     "Timestamp".to_owned(),
                                     vec!["1970-01-01T00:00:01Z".to_owned()],
                                 );
                                 ret.insert(
                                     "TimestampList".to_owned(),
                                     vec![
                                         "1970-01-01T00:00:01Z".to_owned(),
                                         "1970-01-01T00:00:02Z".to_owned(),
                                         "1970-01-01T00:00:03Z".to_owned(),
                                     ],
                                 );
                                 ret.insert("Enum".to_owned(), vec!["Foo".to_owned()]);
                                 ret.insert(
                                     "EnumList".to_owned(),
                                     vec!["Foo".to_owned(), "Baz".to_owned(), "Bar".to_owned()],
                                 );
                                 ret.insert("IntegerEnum".to_owned(), vec!["1".to_owned()]);
                                 ret.insert(
                                     "IntegerEnumList".to_owned(),
                                     vec!["1".to_owned(), "2".to_owned(), "3".to_owned()],
                                 );
                                 ret
                             }),
                         let expected = crate::input::TestNoPayloadInput {
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestNoPayloadOutput {
                             test_id: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-373
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-383
+    }
     /// Handles query string maps
     /// Test ID: RestJsonQueryStringMap
     /// Serializes a GET request with header member but no modeled body
     /// Test ID: RestJsonHttpWithHeaderMemberNoModeledBody
     #[::tokio::test]
     async fn rest_json_query_string_map_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_header_member_no_modeled_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .uri("/no_payload")
             .method("GET")
             .header("X-Amz-Test-Id", "t-12345")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() =
             "/AllQueryStringTypesInput?QueryParamsStringKeyA=Foo&QueryParamsStringKeyB=Bar"
                 .parse()
                 .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
             .test_no_payload(move |input: crate::input::TestNoPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "QueryParamsStringKeyA".to_owned(),
                                     vec!["Foo".to_owned()],
                                 );
                                 ret.insert(
                                     "QueryParamsStringKeyB".to_owned(),
                                     vec!["Bar".to_owned()],
                                 );
                                 ret
                             }),
                             query_string: ::std::option::Option::None,
                             query_string_list: ::std::option::Option::None,
                             query_string_set: ::std::option::Option::None,
                             query_byte: ::std::option::Option::None,
                             query_short: ::std::option::Option::None,
                             query_integer: ::std::option::Option::None,
                             query_integer_list: ::std::option::Option::None,
                             query_integer_set: ::std::option::Option::None,
                             query_long: ::std::option::Option::None,
                             query_float: ::std::option::Option::None,
                             query_double: ::std::option::Option::None,
                             query_double_list: ::std::option::Option::None,
                             query_boolean: ::std::option::Option::None,
                             query_boolean_list: ::std::option::Option::None,
                             query_timestamp: ::std::option::Option::None,
                             query_timestamp_list: ::std::option::Option::None,
                             query_enum: ::std::option::Option::None,
                             query_enum_list: ::std::option::Option::None,
                             query_integer_enum: ::std::option::Option::None,
                             query_integer_enum_list: ::std::option::Option::None,
                         let expected = crate::input::TestNoPayloadInput {
                             test_id: ::std::option::Option::Some("t-12345".to_owned()),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestNoPayloadOutput {
                             test_id: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-417
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-427
+    }
     /// Handles escaping all required characters in the query string.
     /// Test ID: RestJsonQueryStringEscaping
-+
+}
-+
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPayloadBlobInput`](crate::input::TestPayloadBlobInput) using modelled bindings.
     pub struct TestPayloadBlobInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadBlobInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for TestPayloadBlobInputFuture {
     type Output = Result<
         crate::input::TestPayloadBlobInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadBlobInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_test_payload_blob::de_test_payload_blob_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         TestPayloadBlobInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadBlobOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_blob::ser_test_payload_blob_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_payload_blob_test {
-+
     /// Serializes a payload targeting an empty blob
     /// Test ID: RestJsonHttpWithEmptyBlobPayload
     #[::tokio::test]
     async fn rest_json_query_string_escaping_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_blob_payload_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .uri("/blob_payload")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
             .test_payload_blob(move |input: crate::input::TestPayloadBlobInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_string: ::std::option::Option::Some(
                                 " %:/?#[]@!$&'()*+,;=😹".to_owned(),
                         let expected = crate::input::TestPayloadBlobInput {
                             content_type: ::std::option::Option::Some(
                                 "application/octet-stream".to_owned(),
                             ),
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "String".to_owned(),
                                     vec![" %:/?#[]@!$&'()*+,;=😹".to_owned()],
                                 );
                                 ret
                             }),
                             query_string_list: ::std::option::Option::None,
                             query_string_set: ::std::option::Option::None,
                             query_byte: ::std::option::Option::None,
                             query_short: ::std::option::Option::None,
                             query_integer: ::std::option::Option::None,
                             query_integer_list: ::std::option::Option::None,
                             query_integer_set: ::std::option::Option::None,
                             query_long: ::std::option::Option::None,
                             query_float: ::std::option::Option::None,
                             query_double: ::std::option::Option::None,
                             query_double_list: ::std::option::Option::None,
                             query_boolean: ::std::option::Option::None,
                             query_boolean_list: ::std::option::Option::None,
                             query_timestamp: ::std::option::Option::None,
                             query_timestamp_list: ::std::option::Option::None,
                             query_enum: ::std::option::Option::None,
                             query_enum_list: ::std::option::Option::None,
                             query_integer_enum: ::std::option::Option::None,
                             query_integer_enum_list: ::std::option::Option::None,
                             data: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadBlobOutput {
                             content_type: ::std::option::Option::None,
                             data: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-550
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-560
+    }
     /// Supports handling NaN float query values.
     /// Test ID: RestJsonSupportsNaNFloatQueryValues
     /// Serializes a payload targeting a blob
     /// Test ID: RestJsonTestPayloadBlob
     #[::tokio::test]
     async fn rest_json_supports_na_n_float_query_values_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_test_payload_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .uri("/blob_payload")
             .method("POST")
             .header("Content-Type", "image/jpg")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static("1234".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Float=NaN&Double=NaN"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::AllQueryStringTypesInput {
                 query_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                    )
--
+                ,
                 query_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                    )
--
+                ,
                 query_params_map_of_string_list:
                     ::std::option::Option::Some(
--
+                         {
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "Float".to_owned()
--
+                                ,
                                 vec![
                                     "NaN".to_owned()
--
+                                    ,
--
+                                ]
                             );
                             ret.insert(
                                 "Double".to_owned()
--
+                                ,
                                 vec![
                                     "NaN".to_owned()
--
+                                    ,
--
+                                ]
                             );
                             ret
--
+                        }
--
+                    )
--
+                ,
                 query_string:
                     ::std::option::Option::None
--
+                ,
                 query_string_list:
                     ::std::option::Option::None
--
+                ,
                 query_string_set:
                     ::std::option::Option::None
--
+                ,
                 query_byte:
                     ::std::option::Option::None
--
+                ,
                 query_short:
                     ::std::option::Option::None
--
+                ,
                 query_integer:
                     ::std::option::Option::None
--
+                ,
                 query_integer_list:
                     ::std::option::Option::None
--
+                ,
                 query_integer_set:
                     ::std::option::Option::None
--
+                ,
                 query_long:
                     ::std::option::Option::None
--
+                ,
                 query_double_list:
                     ::std::option::Option::None
--
+                ,
                 query_boolean:
                     ::std::option::Option::None
--
+                ,
                 query_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 query_timestamp:
                     ::std::option::Option::None
--
+                ,
                 query_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 query_enum:
                     ::std::option::Option::None
--
+                ,
                 query_enum_list:
                     ::std::option::Option::None
--
+                ,
                 query_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 query_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.query_string, expected.query_string, "Unexpected value for `query_string`");
         ::pretty_assertions::assert_eq!(input.query_string_list, expected.query_string_list, "Unexpected value for `query_string_list`");
         ::pretty_assertions::assert_eq!(input.query_string_set, expected.query_string_set, "Unexpected value for `query_string_set`");
         ::pretty_assertions::assert_eq!(input.query_byte, expected.query_byte, "Unexpected value for `query_byte`");
         ::pretty_assertions::assert_eq!(input.query_short, expected.query_short, "Unexpected value for `query_short`");
         ::pretty_assertions::assert_eq!(input.query_integer, expected.query_integer, "Unexpected value for `query_integer`");
         ::pretty_assertions::assert_eq!(input.query_integer_list, expected.query_integer_list, "Unexpected value for `query_integer_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_set, expected.query_integer_set, "Unexpected value for `query_integer_set`");
         ::pretty_assertions::assert_eq!(input.query_long, expected.query_long, "Unexpected value for `query_long`");
         assert!(input.query_float.float_equals(&expected.query_float),
                                             "Unexpected value for `query_float` {:?} vs. {:?}", expected.query_float, input.query_float);
         assert!(input.query_double.float_equals(&expected.query_double),
                                             "Unexpected value for `query_double` {:?} vs. {:?}", expected.query_double, input.query_double);
         ::pretty_assertions::assert_eq!(input.query_double_list, expected.query_double_list, "Unexpected value for `query_double_list`");
         ::pretty_assertions::assert_eq!(input.query_boolean, expected.query_boolean, "Unexpected value for `query_boolean`");
         ::pretty_assertions::assert_eq!(input.query_boolean_list, expected.query_boolean_list, "Unexpected value for `query_boolean_list`");
         ::pretty_assertions::assert_eq!(input.query_timestamp, expected.query_timestamp, "Unexpected value for `query_timestamp`");
         ::pretty_assertions::assert_eq!(input.query_timestamp_list, expected.query_timestamp_list, "Unexpected value for `query_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.query_enum, expected.query_enum, "Unexpected value for `query_enum`");
         ::pretty_assertions::assert_eq!(input.query_enum_list, expected.query_enum_list, "Unexpected value for `query_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum, expected.query_integer_enum, "Unexpected value for `query_integer_enum`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum_list, expected.query_integer_enum_list, "Unexpected value for `query_integer_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_params_map_of_string_list, expected.query_params_map_of_string_list, "Unexpected value for `query_params_map_of_string_list`");
         let response =
             crate::output::AllQueryStringTypesOutput {
--
+            }
--
+        ;
         Ok(response) };
                                 sender.send(()).await.expect("receiver dropped early");
                                 result
--
+                            }
                         })
                         .build_unchecked();
             .test_payload_blob(move |input: crate::input::TestPayloadBlobInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadBlobInput {
                             content_type: ::std::option::Option::Some("image/jpg".to_owned()),
                             data: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "1234",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadBlobOutput {
                             content_type: ::std::option::Option::None,
                             data: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-608
+    }
     /// Supports handling Infinity float query values.
     /// Test ID: RestJsonSupportsInfinityFloatQueryValues
-+
+}
-+
 const CONTENT_TYPE_TESTPAYLOADSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPayloadStructureInput`](crate::input::TestPayloadStructureInput) using modelled bindings.
     pub struct TestPayloadStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for TestPayloadStructureInputFuture {
     type Output = Result<
         crate::input::TestPayloadStructureInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadStructureInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTPAYLOADSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         TestPayloadStructureInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadStructureOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_structure::ser_test_payload_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod test_payload_structure_test {
-+
     /// Serializes a payload targeting an empty structure
     /// Test ID: RestJsonHttpWithEmptyStructurePayload
     #[::tokio::test]
     async fn rest_json_supports_infinity_float_query_values_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_structure_payload_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .uri("/payload")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static("{}".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Float=Infinity&Double=Infinity"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::AllQueryStringTypesInput {
                 query_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 query_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 query_params_map_of_string_list:
                     ::std::option::Option::Some(
--
+                         {
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "Float".to_owned()
--
+                                ,
                                 vec![
                                     "Infinity".to_owned()
--
+                                    ,
--
+                                ]
                             );
                             ret.insert(
                                 "Double".to_owned()
--
+                                ,
                                 vec![
                                     "Infinity".to_owned()
--
+                                    ,
--
+                                ]
                             );
                             ret
--
+                        }
--
+                    )
--
+                ,
                 query_string:
                     ::std::option::Option::None
--
+                ,
                 query_string_list:
                     ::std::option::Option::None
--
+                ,
                 query_string_set:
                     ::std::option::Option::None
--
+                ,
                 query_byte:
                     ::std::option::Option::None
--
+                ,
                 query_short:
                     ::std::option::Option::None
--
+                ,
                 query_integer:
                     ::std::option::Option::None
--
+                ,
                 query_integer_list:
                     ::std::option::Option::None
--
+                ,
                 query_integer_set:
                     ::std::option::Option::None
--
+                ,
                 query_long:
                     ::std::option::Option::None
--
+                ,
                 query_double_list:
                     ::std::option::Option::None
--
+                ,
                 query_boolean:
                     ::std::option::Option::None
--
+                ,
                 query_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 query_timestamp:
                     ::std::option::Option::None
--
+                ,
                 query_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 query_enum:
                     ::std::option::Option::None
--
+                ,
                 query_enum_list:
                     ::std::option::Option::None
--
+                ,
                 query_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 query_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.query_string, expected.query_string, "Unexpected value for `query_string`");
         ::pretty_assertions::assert_eq!(input.query_string_list, expected.query_string_list, "Unexpected value for `query_string_list`");
         ::pretty_assertions::assert_eq!(input.query_string_set, expected.query_string_set, "Unexpected value for `query_string_set`");
         ::pretty_assertions::assert_eq!(input.query_byte, expected.query_byte, "Unexpected value for `query_byte`");
         ::pretty_assertions::assert_eq!(input.query_short, expected.query_short, "Unexpected value for `query_short`");
         ::pretty_assertions::assert_eq!(input.query_integer, expected.query_integer, "Unexpected value for `query_integer`");
         ::pretty_assertions::assert_eq!(input.query_integer_list, expected.query_integer_list, "Unexpected value for `query_integer_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_set, expected.query_integer_set, "Unexpected value for `query_integer_set`");
         ::pretty_assertions::assert_eq!(input.query_long, expected.query_long, "Unexpected value for `query_long`");
         assert!(input.query_float.float_equals(&expected.query_float),
                                             "Unexpected value for `query_float` {:?} vs. {:?}", expected.query_float, input.query_float);
         assert!(input.query_double.float_equals(&expected.query_double),
                                             "Unexpected value for `query_double` {:?} vs. {:?}", expected.query_double, input.query_double);
         ::pretty_assertions::assert_eq!(input.query_double_list, expected.query_double_list, "Unexpected value for `query_double_list`");
         ::pretty_assertions::assert_eq!(input.query_boolean, expected.query_boolean, "Unexpected value for `query_boolean`");
         ::pretty_assertions::assert_eq!(input.query_boolean_list, expected.query_boolean_list, "Unexpected value for `query_boolean_list`");
         ::pretty_assertions::assert_eq!(input.query_timestamp, expected.query_timestamp, "Unexpected value for `query_timestamp`");
         ::pretty_assertions::assert_eq!(input.query_timestamp_list, expected.query_timestamp_list, "Unexpected value for `query_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.query_enum, expected.query_enum, "Unexpected value for `query_enum`");
         ::pretty_assertions::assert_eq!(input.query_enum_list, expected.query_enum_list, "Unexpected value for `query_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum, expected.query_integer_enum, "Unexpected value for `query_integer_enum`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum_list, expected.query_integer_enum_list, "Unexpected value for `query_integer_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_params_map_of_string_list, expected.query_params_map_of_string_list, "Unexpected value for `query_params_map_of_string_list`");
         let response =
             crate::output::AllQueryStringTypesOutput {
--
+            }
--
+        ;
         Ok(response) };
                                 sender.send(()).await.expect("receiver dropped early");
                                 result
--
+                            }
                         })
                         .build_unchecked();
             .test_payload_structure(move |input: crate::input::TestPayloadStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadStructureInput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadStructureOutput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-750
+    }
     /// Supports handling -Infinity float query values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatQueryValues
     /// Serializes a payload targeting a structure
     /// Test ID: RestJsonTestPayloadStructure
     #[::tokio::test]
     async fn rest_json_supports_negative_infinity_float_query_values_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_test_payload_structure_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .uri("/payload")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static("{\"data\": 25\n}".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Float=-Infinity&Double=-Infinity"
             .parse()
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_payload_structure(move |input: crate::input::TestPayloadStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadStructureInput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::Some(25),
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadStructureOutput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes an request with header members but no payload
     /// Test ID: RestJsonHttpWithHeadersButNoPayload
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_headers_but_no_payload_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/payload")
             .method("POST")
             .header("Content-Type", "application/json")
             .header("X-Amz-Test-Id", "t-12345")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::AllQueryStringTypesInput {
                 query_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 query_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 query_params_map_of_string_list:
                     ::std::option::Option::Some(
--
+                         {
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "Float".to_owned()
--
+                                ,
                                 vec![
                                     "-Infinity".to_owned()
--
+                                    ,
--
+                                ]
                             );
                             ret.insert(
                                 "Double".to_owned()
--
+                                ,
                                 vec![
                                     "-Infinity".to_owned()
--
+                                    ,
--
+                                ]
                             );
                             ret
--
+                        }
--
+                    )
--
+                ,
                 query_string:
                     ::std::option::Option::None
--
+                ,
                 query_string_list:
                     ::std::option::Option::None
--
+                ,
                 query_string_set:
                     ::std::option::Option::None
--
+                ,
                 query_byte:
                     ::std::option::Option::None
--
+                ,
                 query_short:
                     ::std::option::Option::None
--
+                ,
                 query_integer:
                     ::std::option::Option::None
--
+                ,
                 query_integer_list:
                     ::std::option::Option::None
--
+                ,
                 query_integer_set:
                     ::std::option::Option::None
--
+                ,
                 query_long:
                     ::std::option::Option::None
--
+                ,
                 query_double_list:
                     ::std::option::Option::None
--
+                ,
                 query_boolean:
                     ::std::option::Option::None
--
+                ,
                 query_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 query_timestamp:
                     ::std::option::Option::None
--
+                ,
                 query_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 query_enum:
                     ::std::option::Option::None
--
+                ,
                 query_enum_list:
                     ::std::option::Option::None
--
+                ,
                 query_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 query_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.query_string, expected.query_string, "Unexpected value for `query_string`");
         ::pretty_assertions::assert_eq!(input.query_string_list, expected.query_string_list, "Unexpected value for `query_string_list`");
         ::pretty_assertions::assert_eq!(input.query_string_set, expected.query_string_set, "Unexpected value for `query_string_set`");
         ::pretty_assertions::assert_eq!(input.query_byte, expected.query_byte, "Unexpected value for `query_byte`");
         ::pretty_assertions::assert_eq!(input.query_short, expected.query_short, "Unexpected value for `query_short`");
         ::pretty_assertions::assert_eq!(input.query_integer, expected.query_integer, "Unexpected value for `query_integer`");
         ::pretty_assertions::assert_eq!(input.query_integer_list, expected.query_integer_list, "Unexpected value for `query_integer_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_set, expected.query_integer_set, "Unexpected value for `query_integer_set`");
         ::pretty_assertions::assert_eq!(input.query_long, expected.query_long, "Unexpected value for `query_long`");
         assert!(input.query_float.float_equals(&expected.query_float),
                                             "Unexpected value for `query_float` {:?} vs. {:?}", expected.query_float, input.query_float);
         assert!(input.query_double.float_equals(&expected.query_double),
                                             "Unexpected value for `query_double` {:?} vs. {:?}", expected.query_double, input.query_double);
         ::pretty_assertions::assert_eq!(input.query_double_list, expected.query_double_list, "Unexpected value for `query_double_list`");
         ::pretty_assertions::assert_eq!(input.query_boolean, expected.query_boolean, "Unexpected value for `query_boolean`");
         ::pretty_assertions::assert_eq!(input.query_boolean_list, expected.query_boolean_list, "Unexpected value for `query_boolean_list`");
         ::pretty_assertions::assert_eq!(input.query_timestamp, expected.query_timestamp, "Unexpected value for `query_timestamp`");
         ::pretty_assertions::assert_eq!(input.query_timestamp_list, expected.query_timestamp_list, "Unexpected value for `query_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.query_enum, expected.query_enum, "Unexpected value for `query_enum`");
         ::pretty_assertions::assert_eq!(input.query_enum_list, expected.query_enum_list, "Unexpected value for `query_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum, expected.query_integer_enum, "Unexpected value for `query_integer_enum`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum_list, expected.query_integer_enum_list, "Unexpected value for `query_integer_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_params_map_of_string_list, expected.query_params_map_of_string_list, "Unexpected value for `query_params_map_of_string_list`");
         let response =
             crate::output::AllQueryStringTypesOutput {
--
+            }
--
+        ;
         Ok(response) };
                                 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());
--
+    }
     /// Query values of 0 and false are serialized
     /// Test ID: RestJsonZeroAndFalseQueryValues
     #[::tokio::test]
     async fn rest_json_zero_and_false_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Integer=0&Boolean=false"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
             .test_payload_structure(move |input: crate::input::TestPayloadStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_integer: ::std::option::Option::Some(0),
                             query_boolean: ::std::option::Option::Some(false),
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("Integer".to_owned(), vec!["0".to_owned()]);
                                 ret.insert("Boolean".to_owned(), vec!["false".to_owned()]);
                                 ret
                             }),
                             query_string: ::std::option::Option::None,
                             query_string_list: ::std::option::Option::None,
                             query_string_set: ::std::option::Option::None,
                             query_byte: ::std::option::Option::None,
                             query_short: ::std::option::Option::None,
                             query_integer_list: ::std::option::Option::None,
                             query_integer_set: ::std::option::Option::None,
                             query_long: ::std::option::Option::None,
                             query_float: ::std::option::Option::None,
                             query_double: ::std::option::Option::None,
                             query_double_list: ::std::option::Option::None,
                             query_boolean_list: ::std::option::Option::None,
                             query_timestamp: ::std::option::Option::None,
                             query_timestamp_list: ::std::option::Option::None,
                             query_enum: ::std::option::Option::None,
                             query_enum_list: ::std::option::Option::None,
                             query_integer_enum: ::std::option::Option::None,
                             query_integer_enum_list: ::std::option::Option::None,
                         let expected = crate::input::TestPayloadStructureInput {
                             test_id: ::std::option::Option::Some("t-12345".to_owned()),
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadStructureOutput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-849
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-859
+    }
-860
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_constant_and_variable_query_string_test {
     /// Mixes constant and variable query string parameters
     /// Test ID: RestJsonConstantAndVariableQueryStringMissingOneValue
     #[::tokio::test]
     async fn rest_json_constant_and_variable_query_string_missing_one_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ConstantAndVariableQueryString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/ConstantAndVariableQueryString?foo=bar&baz=bam"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .constant_and_variable_query_string(
                 move |input: crate::input::ConstantAndVariableQueryStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::ConstantAndVariableQueryStringInput {
                                 baz: ::std::option::Option::Some("bam".to_owned()),
                                 maybe_set: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::ConstantAndVariableQueryStringOutput {};
                             response
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
--
+                    }
                 },
-+
 const CONTENT_TYPE_TESTBODYSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestBodyStructureInput`](crate::input::TestBodyStructureInput) using modelled bindings.
     pub struct TestBodyStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestBodyStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for TestBodyStructureInputFuture {
     type Output = Result<
         crate::input::TestBodyStructureInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestBodyStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestBodyStructureInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTBODYSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_request(
                 request,
-912
+            )
             .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());
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         TestBodyStructureInputFuture {
             inner: Box::pin(fut),
-+
+        }
-928
+    }
     /// Mixes constant and variable query string parameters
     /// Test ID: RestJsonConstantAndVariableQueryStringAllValues
     #[::tokio::test]
     async fn rest_json_constant_and_variable_query_string_all_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ConstantAndVariableQueryString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/ConstantAndVariableQueryString?foo=bar&baz=bam&maybeSet=yes"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .constant_and_variable_query_string(
                 move |input: crate::input::ConstantAndVariableQueryStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::ConstantAndVariableQueryStringInput {
                                 baz: ::std::option::Option::Some("bam".to_owned()),
                                 maybe_set: ::std::option::Option::Some("yes".to_owned()),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::ConstantAndVariableQueryStringOutput {};
                             response
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestBodyStructureOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-942
+                    }
                 },
--
+            )
             .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());
-943
+    }
-944
+}
 #[cfg(test)]
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_constant_query_string_test {
     /// Includes constant query string parameters
     /// Test ID: RestJsonConstantQueryString
 #[cfg(test)]
 mod test_body_structure_test {
-+
     /// Serializes a structure
     /// Test ID: RestJsonTestBodyStructure
     #[::tokio::test]
     async fn rest_json_constant_query_string_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_test_body_structure_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ConstantQueryString/hi")
             .method("GET")
             .uri("/body")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\"testConfig\":\n    {\"timeout\": 10}\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         *http_request.uri_mut() = "/ConstantQueryString/hi?foo=bar&hello".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .constant_query_string(move |input: crate::input::ConstantQueryStringInput| {
             .test_body_structure(move |input: crate::input::TestBodyStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::ConstantQueryStringInput {
                             hello: "hi".to_owned(),
                         let expected = crate::input::TestBodyStructureInput {
                             test_config: ::std::option::Option::Some(crate::model::TestConfig {
                                 timeout: ::std::option::Option::Some(10),
                             }),
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::ConstantQueryStringOutput {};
                         Ok(response)
                         let response = crate::output::TestBodyStructureOutput {
                             test_id: ::std::option::Option::None,
                             test_config: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-989
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-999
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_document_type_test {
     /// Serializes document types as part of the JSON request payload with no escaping.
     /// Test ID: DocumentTypeInputWithObject
     /// Serializes an empty structure in the body
     /// Test ID: RestJsonHttpWithEmptyBody
     #[::tokio::test]
     async fn document_type_input_with_object_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_http_with_empty_body_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/DocumentType")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\n}".as_bytes()))).unwrap();
         let mut http_request = http::Request::builder()
             .uri("/body")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
             .test_body_structure(move |input: crate::input::TestBodyStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"{
                                 "foo": "bar"
                             }"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         let expected = crate::input::TestBodyStructureInput {
                             test_id: ::std::option::Option::None,
                             test_config: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         let response = crate::output::TestBodyStructureOutput {
                             test_id: ::std::option::Option::None,
                             test_config: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-1035
+                }
             })
             .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());
--
+    }
     /// Serializes document types using a string.
     /// Test ID: DocumentInputWithString
     #[::tokio::test]
     async fn document_input_with_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentType")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#""hello""#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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());
--
+    }
     /// Serializes document types using a number.
     /// Test ID: DocumentInputWithNumber
     #[::tokio::test]
     async fn document_input_with_number_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentType")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"10"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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());
--
+    }
     /// Serializes document types using a boolean.
     /// Test ID: DocumentInputWithBoolean
     #[::tokio::test]
     async fn document_input_with_boolean_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentType")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"stringValue\": \"string\",\n    \"documentValue\": true\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"true"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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());
--
+    }
     /// Serializes document types using a list.
     /// Test ID: DocumentInputWithList
     #[::tokio::test]
     async fn document_input_with_list_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/DocumentType")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringValue\": \"string\",\n    \"documentValue\": [\n        true,\n        \"hi\",\n        [\n            1,\n            2\n        ],\n        {\n            \"foo\": {\n                \"baz\": [\n                    3,\n                    4\n                ]\n            }\n        }\n    ]\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"[
                                 true,
                                 "hi",
--
+                                [
 ,
--
                                 ],
--
+                                {
                                     "foo": {
                                         "baz": [
 ,
--
--
+                                        ]
--
+                                    }
--
+                                }
                             ]"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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());
--
+    }
     /// Serializes documents as part of the JSON response payload with no escaping.
     /// Test ID: DocumentOutput
     #[::tokio::test]
     async fn document_output_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"{
                             "foo": "bar"
                         }"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-1045
+    }
     /// Document types can be JSON scalars too.
     /// Test ID: DocumentOutputString
     #[::tokio::test]
     async fn document_output_string_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#""hello""#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+}
-+
 static CONTENT_TYPE_MALFORMEDACCEPTWITHGENERICSTRING: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithGenericStringInput`](crate::input::MalformedAcceptWithGenericStringInput) using modelled bindings.
     pub struct MalformedAcceptWithGenericStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithGenericStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1059
+    }
     /// Document types can be JSON scalars too.
     /// Test ID: DocumentOutputNumber
     #[::tokio::test]
     async fn document_output_number_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"10"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+}
-+
 impl std::future::Future for MalformedAcceptWithGenericStringInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithGenericStringInput,
         ::aws_smithy_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)
-1074
+    }
     /// Document types can be JSON scalars too.
     /// Test ID: DocumentOutputBoolean
     #[::tokio::test]
     async fn document_output_boolean_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"false"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithGenericStringInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHGENERICSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_accept_with_generic_string::de_malformed_accept_with_generic_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringValue\": \"string\",\n    \"documentValue\": false\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         MalformedAcceptWithGenericStringInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1117
+    }
     /// Document types can be JSON arrays.
     /// Test ID: DocumentOutputArray
     #[::tokio::test]
     async fn document_output_array_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"[
                             true,
                             false
                         ]"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"stringValue\": \"string\",\n    \"documentValue\": [\n        true,\n        false\n    ]\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithGenericStringOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_generic_string::ser_malformed_accept_with_generic_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-1132
+    }
-1133
+}
 #[cfg(test)]
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_document_type_as_map_value_test {
     /// Serializes a map that uses documents as the value.
     /// Test ID: DocumentTypeAsMapValueInput
 #[cfg(test)]
 mod malformed_accept_with_generic_string_test {
-+
     /// When there is a payload without a mediaType trait, the accept must match the
     /// implied content type of the shape.
     /// Test ID: RestJsonWithPayloadExpectsImpliedAccept
     #[::tokio::test]
     async fn document_type_as_map_value_input_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/DocumentTypeAsMapValue")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"docValuedMap\": {\n        \"foo\": { \"f\": 1, \"o\": 2 },\n        \"bar\": [ \"b\", \"a\", \"r\" ],\n        \"baz\": \"BAZ\"\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type_as_map_value(move |input: crate::input::DocumentTypeAsMapValueInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeAsMapValueInput {
                             doc_valued_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("foo".to_owned(), {
                                     let json_bytes = br#"{
                                         "f": 1,
                                         "o": 2
                                     }"#;
                                     let mut tokens =
                                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                             .peekable();
                                     ::aws_smithy_json::deserialize::token::expect_document(
                                         &mut tokens,
--
+                                    )
                                     .expect("well formed json")
                                 });
                                 ret.insert("bar".to_owned(), {
                                     let json_bytes = br#"[
                                         "b",
                                         "a",
                                         "r"
                                     ]"#;
                                     let mut tokens =
                                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                             .peekable();
                                     ::aws_smithy_json::deserialize::token::expect_document(
                                         &mut tokens,
--
+                                    )
                                     .expect("well formed json")
                                 });
                                 ret.insert("baz".to_owned(), {
                                     let json_bytes = br#""BAZ""#;
                                     let mut tokens =
                                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                             .peekable();
                                     ::aws_smithy_json::deserialize::token::expect_document(
                                         &mut tokens,
--
+                                    )
                                     .expect("well formed json")
                                 });
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeAsMapValueOutput {
                             doc_valued_map: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_with_payload_expects_implied_accept_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedAcceptWithGenericString")
                 .method("POST")
                 .header("accept", "application/json")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_accept_with_generic_string(move |input: crate::input::MalformedAcceptWithGenericStringInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedAcceptWithGenericStringOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1179
+    }
     /// Serializes a map that uses documents as the value.
     /// Test ID: DocumentTypeAsMapValueOutput
     #[::tokio::test]
     async fn document_type_as_map_value_output_response() {
         let output = crate::output::DocumentTypeAsMapValueOutput {
             doc_valued_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), {
                     let json_bytes = br#"{
                                     "f": 1,
                                     "o": 2
                                 }"#;
                     let mut tokens =
                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                     ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                         .expect("well formed json")
                 });
                 ret.insert("bar".to_owned(), {
                     let json_bytes = br#"[
                                     "b",
                                     "a",
                                     "r"
                                 ]"#;
                     let mut tokens =
                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                     ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                         .expect("well formed json")
                 });
                 ret.insert("baz".to_owned(), {
                     let json_bytes = br#""BAZ""#;
                     let mut tokens =
                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                     ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                         .expect("well formed json")
                 });
                 ret
             }),
-+
+}
-+
 static CONTENT_TYPE_MALFORMEDACCEPTWITHPAYLOAD: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "image/jpeg"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithPayloadInput`](crate::input::MalformedAcceptWithPayloadInput) using modelled bindings.
     pub struct MalformedAcceptWithPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedAcceptWithPayloadInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithPayloadInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithPayloadInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_accept_with_payload::de_malformed_accept_with_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"docValuedMap\": {\n        \"foo\": { \"f\": 1, \"o\": 2 },\n        \"bar\": [ \"b\", \"a\", \"r\" ],\n        \"baz\": \"BAZ\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedAcceptWithPayloadInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1251
+    }
-1252
+}
 #[cfg(test)]
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithPayloadOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_payload::ser_malformed_accept_with_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_document_type_as_payload_test {
     /// Serializes a document as the target of the httpPayload trait.
     /// Test ID: DocumentTypeAsPayloadInput
 #[cfg(test)]
 mod malformed_accept_with_payload_test {
-+
     /// When there is a payload with a mediaType trait, the accept must match.
     /// Test ID: RestJsonWithPayloadExpectsModeledAccept
     #[::tokio::test]
     async fn document_type_as_payload_input_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentTypeAsPayload")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"foo\": \"bar\"\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type_as_payload(move |input: crate::input::DocumentTypeAsPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeAsPayloadInput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"{
                                 "foo": "bar"
                             }"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeAsPayloadOutput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_with_payload_expects_modeled_accept_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedAcceptWithPayload")
                 .method("POST")
                 .header("accept", "application/json")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_accept_with_payload(move |input: crate::input::MalformedAcceptWithPayloadInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedAcceptWithPayloadOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1312
+    }
     /// Serializes a document as the target of the httpPayload trait using a string.
     /// Test ID: DocumentTypeAsPayloadInputString
     #[::tokio::test]
     async fn document_type_as_payload_input_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentTypeAsPayload")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("\"hello\"".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type_as_payload(move |input: crate::input::DocumentTypeAsPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeAsPayloadInput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#""hello""#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeAsPayloadOutput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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());
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDACCEPTWITHBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithBodyInput`](crate::input::MalformedAcceptWithBodyInput) using modelled bindings.
     pub struct MalformedAcceptWithBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1321
+    }
     /// Serializes a document as the target of the httpPayload trait.
     /// Test ID: DocumentTypeAsPayloadOutput
     #[::tokio::test]
     async fn document_type_as_payload_output_response() {
         let output = crate::output::DocumentTypeAsPayloadOutput {
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"{
                             "foo": "bar"
                         }"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"foo\": \"bar\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+}
-+
 impl std::future::Future for MalformedAcceptWithBodyInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithBodyInput,
         ::aws_smithy_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)
-1336
+    }
     /// Serializes a document as a payload string.
     /// Test ID: DocumentTypeAsPayloadOutputString
     #[::tokio::test]
     async fn document_type_as_payload_output_string_response() {
         let output = crate::output::DocumentTypeAsPayloadOutput {
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#""hello""#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithBodyInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_accept_with_body::de_malformed_accept_with_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "\"hello\"",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         MalformedAcceptWithBodyInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1379
+    }
-1380
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_empty_input_and_empty_output_test {
     /// Clients should not serialize a JSON payload when no parameters
     /// are given that are sent in the body. A service will tolerate
     /// clients that omit a payload or that send a JSON object.
     /// Test ID: RestJsonEmptyInputAndEmptyOutput
     #[::tokio::test]
     async fn rest_json_empty_input_and_empty_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EmptyInputAndEmptyOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .empty_input_and_empty_output(
                 move |input: crate::input::EmptyInputAndEmptyOutputInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EmptyInputAndEmptyOutputInput {};
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::EmptyInputAndEmptyOutputOutput {};
                             response
                         };
                         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());
--
+    }
     /// Similar to RestJsonEmptyInputAndEmptyOutput, but ensures that
     /// services gracefully handles receiving a JSON object.
     /// Test ID: RestJsonEmptyInputAndEmptyOutputWithJson
     #[::tokio::test]
     async fn rest_json_empty_input_and_empty_output_with_json_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EmptyInputAndEmptyOutput")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .empty_input_and_empty_output(
                 move |input: crate::input::EmptyInputAndEmptyOutputInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EmptyInputAndEmptyOutputInput {};
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::EmptyInputAndEmptyOutputOutput {};
                             response
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithBodyOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_body::ser_malformed_accept_with_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-1393
+                    }
                 },
--
+            )
             .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());
--
+    }
     /// As of January 2021, server implementations are expected to
     /// respond with a JSON object regardless of if the output
     /// parameters are empty.
     /// Test ID: RestJsonEmptyInputAndEmptyOutput
     #[::tokio::test]
     async fn rest_json_empty_input_and_empty_output_response() {
         let output = crate::output::EmptyInputAndEmptyOutputOutput {};
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-1394
+    }
-1395
+}
 #[cfg(test)]
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_endpoint_operation_test {
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: RestJsonEndpointTrait
 #[cfg(test)]
 mod malformed_accept_with_body_test {
-+
     /// When there is modeled output, the accept must be application/json
     /// Test ID: RestJsonWithBodyExpectsApplicationJsonAccept
     #[::tokio::test]
     #[should_panic]
     async fn rest_json_endpoint_trait_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EndpointOperation")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         todo!("endpoint trait not supported yet");
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .endpoint_operation(move |input: crate::input::EndpointOperationInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::EndpointOperationInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::EndpointOperationOutput {};
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_with_body_expects_application_json_accept_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedAcceptWithBody")
                 .method("POST")
                 .header("accept", "application/hal+json")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_accept_with_body(move |input: crate::input::MalformedAcceptWithBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedAcceptWithBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1440
+    }
-1441
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_endpoint_with_host_label_operation_test {
     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define
     /// further customization based on user input.
     /// Test ID: RestJsonEndpointTraitWithHostLabel
     #[::tokio::test]
     #[should_panic]
     async fn rest_json_endpoint_trait_with_host_label_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EndpointWithHostLabelOperation")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\"label\": \"bar\"}".as_bytes()),
             ))
             .unwrap();
         todo!("endpoint trait not supported yet");
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .endpoint_with_host_label_operation(
                 move |input: crate::input::EndpointWithHostLabelOperationInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EndpointWithHostLabelOperationInput {
                                 label: "bar".to_owned(),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::EndpointWithHostLabelOperationOutput {};
                             Ok(response)
                         };
                         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());
-+
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHGENERICSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithGenericStringInput`](crate::input::MalformedContentTypeWithGenericStringInput) using modelled bindings.
     pub struct MalformedContentTypeWithGenericStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithGenericStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1449
+    }
-1450
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_greeting_with_errors_test {
     /// Ensures that operations with errors successfully know how
     /// to deserialize a successful response. As of January 2021,
     /// server implementations are expected to respond with a
     /// JSON object regardless of if the output parameters are
     /// empty.
     /// Test ID: RestJsonGreetingWithErrors
     #[::tokio::test]
     async fn rest_json_greeting_with_errors_response() {
         let output = crate::output::GreetingWithErrorsOutput {
             greeting: ::std::option::Option::Some("Hello".to_owned()),
         };
         use ::aws_smithy_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-Greeting", "Hello")];
         ::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("application/json"),
         ));
-+
 impl std::future::Future for MalformedContentTypeWithGenericStringInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithGenericStringInput,
         ::aws_smithy_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)
-1464
+    }
     /// Parses simple JSON errors
     /// Test ID: RestJsonInvalidGreetingError
     #[::tokio::test]
     async fn rest_json_invalid_greeting_error_response() {
         let output = crate::error::InvalidGreeting {
             message: ::std::option::Option::Some("Hi".to_owned()),
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithGenericStringInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHGENERICSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_content_type_with_generic_string::de_malformed_content_type_with_generic_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         let output = crate::error::GreetingWithErrorsError::InvalidGreeting(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
             http_response.status()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [
             ("Content-Type", "application/json"),
             ("X-Amzn-Errortype", "InvalidGreeting"),
         ];
         ::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,
             "{\n    \"Message\": \"Hi\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         MalformedContentTypeWithGenericStringInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1507
+    }
     /// Serializes a complex error with no message member
     /// Test ID: RestJsonComplexErrorWithNoMessage
     #[::tokio::test]
     async fn rest_json_complex_error_with_no_message_response() {
         let output = crate::error::ComplexError {
             header: ::std::option::Option::Some("Header".to_owned()),
             top_level: ::std::option::Option::Some("Top level".to_owned()),
             nested: ::std::option::Option::Some(crate::model::ComplexNestedErrorData {
                 foo: ::std::option::Option::Some("bar".to_owned()),
             }),
         };
         let output = crate::error::GreetingWithErrorsError::ComplexError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(403).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [
             ("Content-Type", "application/json"),
             ("X-Amzn-Errortype", "ComplexError"),
             ("X-Header", "Header"),
         ];
         ::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, "{\n    \"TopLevel\": \"Top level\",\n    \"Nested\": {\n        \"Fooooo\": \"bar\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithGenericStringOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_generic_string::ser_malformed_content_type_with_generic_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-1522
+    }
     /// Test ID: RestJsonEmptyComplexErrorWithNoMessage
     #[::tokio::test]
     async fn rest_json_empty_complex_error_with_no_message_response() {
         let output = crate::error::ComplexError {
             header: ::std::option::Option::None,
             top_level: ::std::option::Option::None,
             nested: ::std::option::Option::None,
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithPayloadInput`](crate::input::MalformedContentTypeWithPayloadInput) using modelled bindings.
     pub struct MalformedContentTypeWithPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedContentTypeWithPayloadInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithPayloadInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithPayloadInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_content_type_with_payload::de_malformed_content_type_with_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         let output = crate::error::GreetingWithErrorsError::ComplexError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(403).expect("invalid expected HTTP status code"),
             http_response.status()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [
             ("Content-Type", "application/json"),
             ("X-Amzn-Errortype", "ComplexError"),
         ];
         ::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("application/json"),
         ));
         MalformedContentTypeWithPayloadInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1589
+    }
-1590
+}
 #[cfg(test)]
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithPayloadOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_payload::ser_malformed_content_type_with_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_http_checksum_required_test {
     /// Adds Content-MD5 header
     /// Test ID: RestJsonHttpChecksumRequired
 #[cfg(test)]
 mod malformed_content_type_with_payload_test {
-+
     /// When there is a payload with a mediaType trait, the content type must match.
     /// Test ID: RestJsonWithPayloadExpectsModeledContentType
     #[::tokio::test]
     async fn rest_json_http_checksum_required_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpChecksumRequired")
             .method("POST")
             .header("Content-MD5", "iB0/3YSo7maijL0IGOgA9g==")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"foo\":\"base64 encoded md5 checksum\"\n}\n".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_checksum_required(move |input: crate::input::HttpChecksumRequiredInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpChecksumRequiredInput {
                             foo: ::std::option::Option::Some(
                                 "base64 encoded md5 checksum".to_owned(),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpChecksumRequiredOutput {
                             foo: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_enum_payload_test {
     /// Test ID: RestJsonEnumPayloadRequest
     #[::tokio::test]
     #[should_panic]
     async fn rest_json_enum_payload_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EnumPayload")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("enumvalue".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_enum_payload(move |input: crate::input::HttpEnumPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpEnumPayloadInput {
                             payload: ::std::option::Option::Some(
                                 "enumvalue"
                                     .parse::<crate::model::StringEnum>()
                                     .expect("static value validated to member"),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpEnumPayloadOutput {
                             payload: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_with_payload_expects_modeled_content_type_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithPayload")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_with_payload(move |input: crate::input::MalformedContentTypeWithPayloadInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithPayloadOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1652
+    }
     /// Test ID: RestJsonEnumPayloadResponse
     /// When there is a payload without a mediaType trait, the content type must match the
     /// implied content type of the shape.
     /// Test ID: RestJsonWithPayloadExpectsImpliedContentType
     #[::tokio::test]
     async fn rest_json_enum_payload_response_response() {
         let output = crate::output::HttpEnumPayloadOutput {
             payload: ::std::option::Option::Some(
                 "enumvalue"
                     .parse::<crate::model::StringEnum>()
                     .expect("static value validated to member"),
             ),
         };
         use ::aws_smithy_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,
             "enumvalue",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_with_payload_expects_implied_content_type_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithPayload")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_with_payload(move |input: crate::input::MalformedContentTypeWithPayloadInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithPayloadOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1695
+    }
-1696
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_payload_traits_test {
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithBlob
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "blobby blob blob",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithNoBlobBody
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_no_blob_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Servers must accept any content type for blob inputs
     /// without the media type trait.
     /// Test ID: RestJsonHttpPayloadTraitsWithBlobAcceptsAllContentTypes
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_blob_accepts_all_content_types_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("Content-Type", "image/jpeg")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("This is definitely a jpeg".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "This is definitely a jpeg",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
-+
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithBodyInput`](crate::input::MalformedContentTypeWithBodyInput) using modelled bindings.
     pub struct MalformedContentTypeWithBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1704
+    }
     /// Servers must accept any accept header for blob inputs
     /// without the media type trait.
     /// Test ID: RestJsonHttpPayloadTraitsWithBlobAcceptsAllAccepts
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_blob_accepts_all_accepts_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("Accept", "image/jpeg")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("This is definitely a jpeg".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "This is definitely a jpeg",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
-+
+}
-+
 impl std::future::Future for MalformedContentTypeWithBodyInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithBodyInput,
         ::aws_smithy_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)
-1719
+    }
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithBlob
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_blob_response() {
         let output = crate::output::HttpPayloadTraitsOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")),
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithBodyInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_content_type_with_body::de_malformed_content_type_with_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("X-Foo", "Foo")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
         MalformedContentTypeWithBodyInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1762
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithNoBlobBody
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_no_blob_body_response() {
         let output = crate::output::HttpPayloadTraitsOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Foo", "Foo")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithBodyOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_body::ser_malformed_content_type_with_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-1777
+    }
-1778
+}
 #[cfg(test)]
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_http_payload_traits_with_media_type_test {
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob
 #[cfg(test)]
 mod malformed_content_type_with_body_test {
-+
     /// When there is modeled input, they content type must be application/json
     /// Test ID: RestJsonWithBodyExpectsApplicationJsonContentType
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_media_type_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraitsWithMediaType")
             .method("POST")
             .header("Content-Type", "text/plain")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits_with_media_type(
                 move |input: crate::input::HttpPayloadTraitsWithMediaTypeInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpPayloadTraitsWithMediaTypeInput {
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                                 blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                     "blobby blob blob",
                                 )),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpPayloadTraitsWithMediaTypeOutput {
                                 foo: ::std::option::Option::None,
                                 blob: ::std::option::Option::None,
                             };
                             response
                         };
                         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());
     #[::tracing_test::traced_test]
     async fn rest_json_with_body_expects_application_json_content_type_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithBody")
                 .method("POST")
                 .header("content-type", "application/hal+json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_with_body(move |input: crate::input::MalformedContentTypeWithBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1825
+    }
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     async fn rest_json_http_payload_traits_with_media_type_with_blob_response() {
         let output = crate::output::HttpPayloadTraitsWithMediaTypeOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")),
         };
         use ::aws_smithy_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 = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHOUTBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithoutBodyInput`](crate::input::MalformedContentTypeWithoutBodyInput) using modelled bindings.
     pub struct MalformedContentTypeWithoutBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithoutBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1834
+    }
-1835
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_payload_with_structure_test {
     /// Serializes a structure in the payload
     /// Test ID: RestJsonHttpPayloadWithStructure
     #[::tokio::test]
     async fn rest_json_http_payload_with_structure_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadWithStructure")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_with_structure(
                 move |input: crate::input::HttpPayloadWithStructureInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpPayloadWithStructureInput {
                                 nested: ::std::option::Option::Some(crate::model::NestedPayload {
                                     greeting: ::std::option::Option::Some("hello".to_owned()),
                                     name: ::std::option::Option::Some("Phreddy".to_owned()),
                                 }),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpPayloadWithStructureOutput {
                                 nested: ::std::option::Option::Some(crate::model::NestedPayload {
                                     greeting: ::std::option::Option::None,
                                     name: ::std::option::Option::None,
                                 }),
                             };
                             response
                         };
                         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());
-+
 impl std::future::Future for MalformedContentTypeWithoutBodyInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithoutBodyInput,
         ::aws_smithy_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)
-1849
+    }
     /// Serializes a structure in the payload
     /// Test ID: RestJsonHttpPayloadWithStructure
     #[::tokio::test]
     async fn rest_json_http_payload_with_structure_response() {
         let output = crate::output::HttpPayloadWithStructureOutput {
             nested: ::std::option::Option::Some(crate::model::NestedPayload {
                 greeting: ::std::option::Option::Some("hello".to_owned()),
                 name: ::std::option::Option::Some("Phreddy".to_owned()),
             }),
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithoutBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithoutBodyInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHOUTBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_content_type_without_body::de_malformed_content_type_without_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         MalformedContentTypeWithoutBodyInputFuture {
             inner: Box::pin(fut),
-+
+        }
-1892
+    }
-1893
+}
 #[cfg(test)]
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithoutBodyOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_without_body::ser_malformed_content_type_without_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_http_payload_with_union_test {
     /// Serializes a union in the payload.
     /// Test ID: RestJsonHttpPayloadWithUnion
 #[cfg(test)]
 mod malformed_content_type_without_body_test {
-+
     /// When there is no modeled input, content type must not be set and the body must be empty.
     /// Test ID: RestJsonWithoutBodyExpectsEmptyContentType
     #[::tokio::test]
     async fn rest_json_http_payload_with_union_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadWithUnion")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"greeting\": \"hello\"\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_with_union(move |input: crate::input::HttpPayloadWithUnionInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadWithUnionInput {
                             nested: ::std::option::Option::Some(
                                 crate::model::UnionPayload::Greeting("hello".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadWithUnionOutput {
                             nested: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_without_body_expects_empty_content_type_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithoutBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_without_body(move |input: crate::input::MalformedContentTypeWithoutBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithoutBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-1955
+    }
     /// No payload is sent if the union has no value.
     /// Test ID: RestJsonHttpPayloadWithUnsetUnion
     #[::tokio::test]
     async fn rest_json_http_payload_with_unset_union_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadWithUnion")
             .method("PUT")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_with_union(move |input: crate::input::HttpPayloadWithUnionInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadWithUnionInput {
                             nested: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadWithUnionOutput {
                             nested: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPBODYHTTPDATE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyHttpDateInput`](crate::input::MalformedTimestampBodyHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampBodyHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-1964
+    }
     /// Serializes a union in the payload.
     /// Test ID: RestJsonHttpPayloadWithUnion
     #[::tokio::test]
     async fn rest_json_http_payload_with_union_response() {
         let output = crate::output::HttpPayloadWithUnionOutput {
             nested: ::std::option::Option::Some(crate::model::UnionPayload::Greeting(
                 "hello".to_owned(),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"greeting\": \"hello\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+}
-+
 impl std::future::Future for MalformedTimestampBodyHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyHttpDateInput,
         ::aws_smithy_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)
-1979
+    }
     /// No payload is sent if the union has no value.
     /// Test ID: RestJsonHttpPayloadWithUnsetUnion
     #[::tokio::test]
     async fn rest_json_http_payload_with_unset_union_response() {
         let output = crate::output::HttpPayloadWithUnionOutput {
             nested: ::std::option::Option::None,
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyHttpDateInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_http_date::de_malformed_timestamp_body_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Length", "0")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
         MalformedTimestampBodyHttpDateInputFuture {
             inner: Box::pin(fut),
-+
+        }
-2022
+    }
-2023
+}
 #[cfg(test)]
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyHttpDateOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyHttpDateError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_http_prefix_headers_test {
     /// Adds headers by prefix
     /// Test ID: RestJsonHttpPrefixHeadersArePresent
 #[cfg(test)]
 mod malformed_timestamp_body_http_date_test {
-+
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_http_prefix_headers_are_present_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPrefixHeaders")
             .method("GET")
             .header("X-Foo", "Foo")
             .header("X-Foo-Abc", "Abc value")
             .header("X-Foo-Def", "Def value")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_prefix_headers(move |input: crate::input::HttpPrefixHeadersInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPrefixHeadersInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             foo_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "Abc".to_owned().to_ascii_lowercase(),
                                     "Abc value".to_owned(),
                                 );
                                 ret.insert(
                                     "Def".to_owned().to_ascii_lowercase(),
                                     "Def value".to_owned(),
                                 );
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPrefixHeadersOutput {
                             foo: ::std::option::Option::None,
                             foo_map: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_http_date_rejects_date_time_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50.52Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2106
+    }
     /// Adds headers by prefix
     /// Test ID: RestJsonHttpPrefixHeadersArePresent
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_http_prefix_headers_are_present_response() {
         let output = crate::output::HttpPrefixHeadersOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             foo_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "Abc".to_owned().to_ascii_lowercase(),
                     "Abc value".to_owned(),
                 );
                 ret.insert(
                     "Def".to_owned().to_ascii_lowercase(),
                     "Def value".to_owned(),
                 );
                 ret
             }),
         };
         use ::aws_smithy_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-Foo", "Foo"),
             ("X-Foo-Abc", "Abc value"),
             ("X-Foo-Def", "Def value"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_http_date_rejects_date_time_case1_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2151
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_prefix_headers_in_response_test {
     /// (de)serializes all response headers
     /// Test ID: HttpPrefixHeadersResponse
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsDateTime_case2
     #[::tokio::test]
     async fn http_prefix_headers_response_response() {
         let output = crate::output::HttpPrefixHeadersInResponseOutput {
             prefix_headers: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("X-Foo".to_owned().to_ascii_lowercase(), "Foo".to_owned());
                 ret.insert("Hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());
                 ret
             }),
         };
         use ::aws_smithy_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 = [("Hello", "Hello"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_http_date_rejects_date_time_case2_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57-08:00\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2196
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_request_with_float_labels_test {
     /// Supports handling NaN float label values.
     /// Test ID: RestJsonSupportsNaNFloatLabels
     /// When the format is http-date, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsEpoch_case0
     #[::tokio::test]
     async fn rest_json_supports_na_n_float_labels_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/FloatHttpLabels/NaN/NaN")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .http_request_with_float_labels(move |input: crate::input::HttpRequestWithFloatLabelsInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::HttpRequestWithFloatLabelsInput {
                 float:
                     <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                ,
                 double:
                     <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                ,
--
+            }
--
+        ;
         assert!(input.float.float_equals(&expected.float),
                                             "Unexpected value for `float` {:?} vs. {:?}", expected.float, input.float);
         assert!(input.double.float_equals(&expected.double),
                                             "Unexpected value for `double` {:?} vs. {:?}", expected.double, input.double);
         let response =
             crate::output::HttpRequestWithFloatLabelsOutput {
--
+            }
--
+        ;
         Ok(response) };
                                 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());
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_http_date_rejects_epoch_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081.1234 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2239
+    }
     /// Supports handling Infinity float label values.
     /// Test ID: RestJsonSupportsInfinityFloatLabels
     /// When the format is http-date, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsEpoch_case1
     #[::tokio::test]
     async fn rest_json_supports_infinity_float_labels_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/FloatHttpLabels/Infinity/Infinity")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .http_request_with_float_labels(move |input: crate::input::HttpRequestWithFloatLabelsInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::HttpRequestWithFloatLabelsInput {
                 float:
                     <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                ,
                 double:
                     <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                ,
--
+            }
--
+        ;
         assert!(input.float.float_equals(&expected.float),
                                             "Unexpected value for `float` {:?} vs. {:?}", expected.float, input.float);
         assert!(input.double.float_equals(&expected.double),
                                             "Unexpected value for `double` {:?} vs. {:?}", expected.double, input.double);
         let response =
             crate::output::HttpRequestWithFloatLabelsOutput {
--
+            }
--
+        ;
         Ok(response) };
                                 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());
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_http_date_rejects_epoch_case1_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2282
+    }
     /// Supports handling -Infinity float label values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatLabels
     #[::tokio::test]
     async fn rest_json_supports_negative_infinity_float_labels_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/FloatHttpLabels/-Infinity/-Infinity")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .http_request_with_float_labels(move |input: crate::input::HttpRequestWithFloatLabelsInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::HttpRequestWithFloatLabelsInput {
                 float:
                     <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                ,
                 double:
                     <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                ,
--
+            }
--
+        ;
         assert!(input.float.float_equals(&expected.float),
                                             "Unexpected value for `float` {:?} vs. {:?}", expected.float, input.float);
         assert!(input.double.float_equals(&expected.double),
                                             "Unexpected value for `double` {:?} vs. {:?}", expected.double, input.double);
         let response =
             crate::output::HttpRequestWithFloatLabelsOutput {
--
+            }
--
+        ;
         Ok(response) };
                                 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());
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDATETIME: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyDateTimeInput`](crate::input::MalformedTimestampBodyDateTimeInput) using modelled bindings.
     pub struct MalformedTimestampBodyDateTimeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDateTimeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-2291
+    }
-2292
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_request_with_greedy_label_in_path_test {
     /// Serializes greedy labels and normal labels
     /// Test ID: RestJsonHttpRequestWithGreedyLabelInPath
     #[::tokio::test]
     async fn rest_json_http_request_with_greedy_label_in_path_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpRequestWithGreedyLabelInPath/foo/hello%2Fescape/baz/there/guy")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_greedy_label_in_path(
                 move |input: crate::input::HttpRequestWithGreedyLabelInPathInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpRequestWithGreedyLabelInPathInput {
                                 foo: "hello/escape".to_owned(),
                                 baz: "there/guy".to_owned(),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpRequestWithGreedyLabelInPathOutput {};
                             Ok(response)
                         };
                         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());
-+
 impl std::future::Future for MalformedTimestampBodyDateTimeInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyDateTimeInput,
         ::aws_smithy_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)
-2306
+    }
-2307
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_request_with_labels_test {
     /// Sends a GET request that uses URI label bindings
     /// Test ID: RestJsonInputWithHeadersAndAllParams
     #[::tokio::test]
     async fn rest_json_input_with_headers_and_all_params_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpRequestWithLabels/string/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_labels(move |input: crate::input::HttpRequestWithLabelsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::HttpRequestWithLabelsInput {
                             string: "string".to_owned(),
                             short: 1,
                             integer: 2,
                             long: 3,
                             float: 4.1_f32,
                             double: 5.1_f64,
                             boolean: true,
                             timestamp: ::aws_smithy_types::DateTime::from_fractional_secs(
                                 1576540098, 0_f64,
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.string,
                             expected.string,
                             "Unexpected value for `string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short,
                             expected.short,
                             "Unexpected value for `short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer,
                             expected.integer,
                             "Unexpected value for `integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long,
                             expected.long,
                             "Unexpected value for `long`"
                         );
                         assert!(
                             input.float.float_equals(&expected.float),
                             "Unexpected value for `float` {:?} vs. {:?}",
                             expected.float,
                             input.float
                         );
                         assert!(
                             input.double.float_equals(&expected.double),
                             "Unexpected value for `double` {:?} vs. {:?}",
                             expected.double,
                             input.double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.boolean,
                             expected.boolean,
                             "Unexpected value for `boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.timestamp,
                             expected.timestamp,
                             "Unexpected value for `timestamp`"
                         );
                         let response = crate::output::HttpRequestWithLabelsOutput {};
                         Ok(response)
                     };
                     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());
--
+    }
     /// Sends a GET request that uses URI label bindings
     /// Test ID: RestJsonHttpRequestLabelEscaping
     #[::tokio::test]
     async fn rest_json_http_request_label_escaping_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/HttpRequestWithLabels/%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z")
                         .method("GET")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_labels(move |input: crate::input::HttpRequestWithLabelsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::HttpRequestWithLabelsInput {
                             string: " %:/?#[]@!$&'()*+,;=😹".to_owned(),
                             short: 1,
                             integer: 2,
                             long: 3,
                             float: 4.1_f32,
                             double: 5.1_f64,
                             boolean: true,
                             timestamp: ::aws_smithy_types::DateTime::from_fractional_secs(
                                 1576540098, 0_f64,
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.string,
                             expected.string,
                             "Unexpected value for `string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short,
                             expected.short,
                             "Unexpected value for `short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer,
                             expected.integer,
                             "Unexpected value for `integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long,
                             expected.long,
                             "Unexpected value for `long`"
                         );
                         assert!(
                             input.float.float_equals(&expected.float),
                             "Unexpected value for `float` {:?} vs. {:?}",
                             expected.float,
                             input.float
                         );
                         assert!(
                             input.double.float_equals(&expected.double),
                             "Unexpected value for `double` {:?} vs. {:?}",
                             expected.double,
                             input.double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.boolean,
                             expected.boolean,
                             "Unexpected value for `boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.timestamp,
                             expected.timestamp,
                             "Unexpected value for `timestamp`"
                         );
                         let response = crate::output::HttpRequestWithLabelsOutput {};
                         Ok(response)
                     };
                     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());
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_request_with_labels_and_timestamp_format_test {
     /// Serializes different timestamp formats in URI labels
     /// Test ID: RestJsonHttpRequestWithLabelsAndTimestampFormat
     #[::tokio::test]
     async fn rest_json_http_request_with_labels_and_timestamp_format_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/HttpRequestWithLabelsAndTimestampFormat/1576540098/Mon%2C%2016%20Dec%202019%2023%3A48%3A18%20GMT/2019-12-16T23%3A48%3A18Z/2019-12-16T23%3A48%3A18Z/1576540098/Mon%2C%2016%20Dec%202019%2023%3A48%3A18%20GMT/2019-12-16T23%3A48%3A18Z")
                         .method("GET")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service =
             crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                 .http_request_with_labels_and_timestamp_format(
                     move |input: crate::input::HttpRequestWithLabelsAndTimestampFormatInput| {
                         let sender = sender.clone();
                         async move {
                             let result =
--
+                                {
                                     let expected =
             crate::input::HttpRequestWithLabelsAndTimestampFormatInput {
                 member_epoch_seconds:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
                 member_http_date:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
                 member_date_time:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
                 default_format:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
                 target_epoch_seconds:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
                 target_http_date:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
                 target_date_time:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
--
+                ,
--
+            }
--
+        ;
                                     ::pretty_assertions::assert_eq!(input, expected);
                                     let response =
             crate::output::HttpRequestWithLabelsAndTimestampFormatOutput {
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDateTimeInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDATETIME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2332
+            }
--
+        ;
                                     Ok(response)
                                 };
                             sender.send(()).await.expect("receiver dropped early");
                             result
--
+                        }
                     },
             crate::protocol_serde::shape_malformed_timestamp_body_date_time::de_malformed_timestamp_body_date_time_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2343
+                )
                 .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());
             },
         );
         MalformedTimestampBodyDateTimeInputFuture {
             inner: Box::pin(fut),
-+
+        }
-2349
+    }
-2350
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_request_with_regex_literal_test {
     /// Path matching is not broken by regex expressions in literal segments
     /// Test ID: RestJsonToleratesRegexCharsInSegments
     #[::tokio::test]
     async fn rest_json_tolerates_regex_chars_in_segments_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ReDosLiteral/abc/(a+)+")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_regex_literal(
                 move |input: crate::input::HttpRequestWithRegexLiteralInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpRequestWithRegexLiteralInput {
                                 str: "abc".to_owned(),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpRequestWithRegexLiteralOutput {};
                             Ok(response)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDateTimeOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-2363
+                    }
                 },
--
+            )
             .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());
-2364
+    }
-2365
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_http_response_code_test {
     /// Binds the http response code to an output structure. Note that
     /// even though all members are bound outside of the payload, an
     /// empty JSON object is serialized in the response. However,
     /// clients should be able to handle an empty JSON object or an
     /// empty payload without failing to deserialize a response.
     /// Test ID: RestJsonHttpResponseCode
     #[::tokio::test]
     async fn rest_json_http_response_code_response() {
         let output = crate::output::HttpResponseCodeOutput {
             status: ::std::option::Option::Some(201),
         };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(201).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
--
+    }
     /// Binds the http response code to the http trait's code if the
     /// code isn't explicitly set. A client would be parsing the
     /// http response code, so this would always be present, but
     /// a server doesn't require it to be set to serialize a request.
     /// Test ID: RestJsonHttpResponseCodeDefaultsToModeledCode
     #[::tokio::test]
     async fn rest_json_http_response_code_defaults_to_modeled_code_response() {
         let output = crate::output::HttpResponseCodeOutput {
             status: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyDateTimeError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-2382
+    }
-2383
+}
 #[cfg(test)]
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_http_string_payload_test {
     /// Test ID: RestJsonStringPayloadRequest
     #[::tokio::test]
     #[should_panic]
     async fn rest_json_string_payload_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StringPayload")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("rawstring".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_string_payload(move |input: crate::input::HttpStringPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpStringPayloadInput {
                             payload: ::std::option::Option::Some("rawstring".to_owned()),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpStringPayloadOutput {
                             payload: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Test ID: RestJsonStringPayloadResponse
 #[cfg(test)]
 mod malformed_timestamp_body_date_time_test {
-+
     /// When the format is date-time, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_string_payload_response_response() {
         let output = crate::output::HttpStringPayloadOutput {
             payload: ::std::option::Option::Some("rawstring".to_owned()),
         };
         use ::aws_smithy_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,
             "rawstring",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_http_date_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"Tue, 29 Apr 2014 18:30:38 GMT\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2433
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_ignore_query_params_in_response_test {
     /// Query parameters must be ignored when serializing the output
     /// of an operation. As of January 2021, server implementations
     /// are expected to respond with a JSON object regardless of
     /// if the output parameters are empty.
     /// Test ID: RestJsonIgnoreQueryParamsInResponse
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_ignore_query_params_in_response_response() {
         let output = crate::output::IgnoreQueryParamsInResponseOutput {
             baz: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_epoch_seconds_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081.1234 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2476
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_input_and_output_with_headers_test {
     /// Tests requests with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_input_and_output_with_string_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-String", "Hello")
             .header("X-StringList", "a, b, c")
             .header("X-StringSet", "a, b, c")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_string: ::std::option::Option::Some("Hello".to_owned()),
                                 header_string_list: ::std::option::Option::Some(vec![
                                     "a".to_owned(),
                                     "b".to_owned(),
                                     "c".to_owned(),
                                 ]),
                                 header_string_set: ::std::option::Option::Some(
                                     vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]
                                         .try_into()
                                         .expect("this is only used in tests"),
                                 ),
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_epoch_seconds_case1_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2519
+    }
     /// Tests requests with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     /// When the format is date-time, RFC 3339 timestamps with a UTC offset are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsUTCOffsets_case0
     #[::tokio::test]
     async fn rest_json_input_and_output_with_quoted_string_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-StringList", "\"b,c\", \"\\\"def\\\"\", a")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_string_list: ::std::option::Option::Some(vec![
                                     "b,c".to_owned(),
                                     "\"def\"".to_owned(),
                                     "a".to_owned(),
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_utc_offsets_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57-08:00\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-2564
+    }
     /// Tests requests with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case0
     #[::tokio::test]
     async fn rest_json_input_and_output_with_numeric_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Byte", "1")
             .header("X-Double", "1.1")
             .header("X-Float", "1.1")
             .header("X-Integer", "123")
             .header("X-IntegerList", "1, 2, 3")
             .header("X-Long", "123")
             .header("X-Short", "123")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_byte: ::std::option::Option::Some(1),
                                 header_short: ::std::option::Option::Some(123),
                                 header_integer: ::std::option::Option::Some(123),
                                 header_long: ::std::option::Option::Some(123),
                                 header_float: ::std::option::Option::Some(1.1_f32),
                                 header_double: ::std::option::Option::Some(1.1_f64),
                                 header_integer_list: ::std::option::Option::Some(vec![1, 2, 3]),
                                 header_string: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
--
+    }
     /// Tests requests with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_boolean_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Boolean1", "true")
             .header("X-Boolean2", "false")
             .header("X-BooleanList", "true, false, true")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_true_bool: ::std::option::Option::Some(true),
                                 header_false_bool: ::std::option::Option::Some(false),
                                 header_boolean_list: ::std::option::Option::Some(vec![
                                     true, false, true,
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
--
+    }
     /// Tests requests with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_timestamp_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header(
                 "X-TimestampList",
                 "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT",
--
+            )
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_timestamp_list: ::std::option::Option::Some(vec![
                                     ::aws_smithy_types::DateTime::from_fractional_secs(
                                         1576540098, 0_f64,
                                     ),
                                     ::aws_smithy_types::DateTime::from_fractional_secs(
                                         1576540098, 0_f64,
                                     ),
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
--
+    }
     /// Tests requests with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_enum_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Enum", "Foo")
             .header("X-EnumList", "Foo, Bar, Baz")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_enum: ::std::option::Option::Some(
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 ),
                                 header_enum_list: ::std::option::Option::Some(vec![
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                     "Bar"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                     "Baz"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
--
+    }
     /// Tests requests with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_int_enum_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-IntegerEnum", "1")
             .header("X-IntegerEnumList", "1, 2, 3")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_integer_enum: ::std::option::Option::Some(1),
                                 header_integer_enum_list: ::std::option::Option::Some(vec![
 , 2, 3,
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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());
--
+    }
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderInputs
     #[::tokio::test]
     async fn rest_json_supports_na_n_float_header_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Double", "NaN")
             .header("X-Float", "NaN")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .input_and_output_with_headers(move |input: crate::input::InputAndOutputWithHeadersInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::InputAndOutputWithHeadersInput {
                 header_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                    )
--
+                ,
                 header_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                    )
--
+                ,
                 header_string:
                     ::std::option::Option::None
--
+                ,
                 header_byte:
                     ::std::option::Option::None
--
+                ,
                 header_short:
                     ::std::option::Option::None
--
+                ,
                 header_integer:
                     ::std::option::Option::None
--
+                ,
                 header_long:
                     ::std::option::Option::None
--
+                ,
                 header_true_bool:
                     ::std::option::Option::None
--
+                ,
                 header_false_bool:
                     ::std::option::Option::None
--
+                ,
                 header_string_list:
                     ::std::option::Option::None
--
+                ,
                 header_string_set:
                     ::std::option::Option::None
--
+                ,
                 header_integer_list:
                     ::std::option::Option::None
--
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 header_enum:
                     ::std::option::Option::None
--
+                ,
                 header_enum_list:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.header_string, expected.header_string, "Unexpected value for `header_string`");
         ::pretty_assertions::assert_eq!(input.header_byte, expected.header_byte, "Unexpected value for `header_byte`");
         ::pretty_assertions::assert_eq!(input.header_short, expected.header_short, "Unexpected value for `header_short`");
         ::pretty_assertions::assert_eq!(input.header_integer, expected.header_integer, "Unexpected value for `header_integer`");
         ::pretty_assertions::assert_eq!(input.header_long, expected.header_long, "Unexpected value for `header_long`");
         assert!(input.header_float.float_equals(&expected.header_float),
                                             "Unexpected value for `header_float` {:?} vs. {:?}", expected.header_float, input.header_float);
         assert!(input.header_double.float_equals(&expected.header_double),
                                             "Unexpected value for `header_double` {:?} vs. {:?}", expected.header_double, input.header_double);
         ::pretty_assertions::assert_eq!(input.header_true_bool, expected.header_true_bool, "Unexpected value for `header_true_bool`");
         ::pretty_assertions::assert_eq!(input.header_false_bool, expected.header_false_bool, "Unexpected value for `header_false_bool`");
         ::pretty_assertions::assert_eq!(input.header_string_list, expected.header_string_list, "Unexpected value for `header_string_list`");
         ::pretty_assertions::assert_eq!(input.header_string_set, expected.header_string_set, "Unexpected value for `header_string_set`");
         ::pretty_assertions::assert_eq!(input.header_integer_list, expected.header_integer_list, "Unexpected value for `header_integer_list`");
         ::pretty_assertions::assert_eq!(input.header_boolean_list, expected.header_boolean_list, "Unexpected value for `header_boolean_list`");
         ::pretty_assertions::assert_eq!(input.header_timestamp_list, expected.header_timestamp_list, "Unexpected value for `header_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.header_enum, expected.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(input.header_enum_list, expected.header_enum_list, "Unexpected value for `header_enum_list`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum, expected.header_integer_enum, "Unexpected value for `header_integer_enum`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum_list, expected.header_integer_enum_list, "Unexpected value for `header_integer_enum_list`");
         let response =
             crate::output::InputAndOutputWithHeadersOutput {
                 header_string:
                     ::std::option::Option::None
--
+                ,
                 header_byte:
                     ::std::option::Option::None
--
+                ,
                 header_short:
                     ::std::option::Option::None
--
+                ,
                 header_integer:
                     ::std::option::Option::None
--
+                ,
                 header_long:
                     ::std::option::Option::None
--
+                ,
                 header_float:
                     ::std::option::Option::None
--
+                ,
                 header_double:
                     ::std::option::Option::None
--
+                ,
                 header_true_bool:
                     ::std::option::Option::None
--
+                ,
                 header_false_bool:
                     ::std::option::Option::None
--
+                ,
                 header_string_list:
                     ::std::option::Option::None
--
+                ,
                 header_string_set:
                     ::std::option::Option::None
--
+                ,
                 header_integer_list:
                     ::std::option::Option::None
--
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 header_enum:
                     ::std::option::Option::None
--
+                ,
                 header_enum_list:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         Ok(response) };
                                 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());
--
+    }
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderInputs
     #[::tokio::test]
     async fn rest_json_supports_infinity_float_header_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Double", "Infinity")
             .header("X-Float", "Infinity")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .input_and_output_with_headers(move |input: crate::input::InputAndOutputWithHeadersInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::InputAndOutputWithHeadersInput {
                 header_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 header_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 header_string:
                     ::std::option::Option::None
--
+                ,
                 header_byte:
                     ::std::option::Option::None
--
+                ,
                 header_short:
                     ::std::option::Option::None
--
+                ,
                 header_integer:
                     ::std::option::Option::None
--
+                ,
                 header_long:
                     ::std::option::Option::None
--
+                ,
                 header_true_bool:
                     ::std::option::Option::None
--
+                ,
                 header_false_bool:
                     ::std::option::Option::None
--
+                ,
                 header_string_list:
                     ::std::option::Option::None
--
+                ,
                 header_string_set:
                     ::std::option::Option::None
--
+                ,
                 header_integer_list:
                     ::std::option::Option::None
--
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 header_enum:
                     ::std::option::Option::None
--
+                ,
                 header_enum_list:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.header_string, expected.header_string, "Unexpected value for `header_string`");
         ::pretty_assertions::assert_eq!(input.header_byte, expected.header_byte, "Unexpected value for `header_byte`");
         ::pretty_assertions::assert_eq!(input.header_short, expected.header_short, "Unexpected value for `header_short`");
         ::pretty_assertions::assert_eq!(input.header_integer, expected.header_integer, "Unexpected value for `header_integer`");
         ::pretty_assertions::assert_eq!(input.header_long, expected.header_long, "Unexpected value for `header_long`");
         assert!(input.header_float.float_equals(&expected.header_float),
                                             "Unexpected value for `header_float` {:?} vs. {:?}", expected.header_float, input.header_float);
         assert!(input.header_double.float_equals(&expected.header_double),
                                             "Unexpected value for `header_double` {:?} vs. {:?}", expected.header_double, input.header_double);
         ::pretty_assertions::assert_eq!(input.header_true_bool, expected.header_true_bool, "Unexpected value for `header_true_bool`");
         ::pretty_assertions::assert_eq!(input.header_false_bool, expected.header_false_bool, "Unexpected value for `header_false_bool`");
         ::pretty_assertions::assert_eq!(input.header_string_list, expected.header_string_list, "Unexpected value for `header_string_list`");
         ::pretty_assertions::assert_eq!(input.header_string_set, expected.header_string_set, "Unexpected value for `header_string_set`");
         ::pretty_assertions::assert_eq!(input.header_integer_list, expected.header_integer_list, "Unexpected value for `header_integer_list`");
         ::pretty_assertions::assert_eq!(input.header_boolean_list, expected.header_boolean_list, "Unexpected value for `header_boolean_list`");
         ::pretty_assertions::assert_eq!(input.header_timestamp_list, expected.header_timestamp_list, "Unexpected value for `header_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.header_enum, expected.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(input.header_enum_list, expected.header_enum_list, "Unexpected value for `header_enum_list`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum, expected.header_integer_enum, "Unexpected value for `header_integer_enum`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum_list, expected.header_integer_enum_list, "Unexpected value for `header_integer_enum_list`");
         let response =
             crate::output::InputAndOutputWithHeadersOutput {
                 header_string:
                     ::std::option::Option::None
--
+                ,
                 header_byte:
                     ::std::option::Option::None
--
+                ,
                 header_short:
                     ::std::option::Option::None
--
+                ,
                 header_integer:
                     ::std::option::Option::None
--
+                ,
                 header_long:
                     ::std::option::Option::None
--
+                ,
                 header_float:
                     ::std::option::Option::None
--
+                ,
                 header_double:
                     ::std::option::Option::None
--
+                ,
                 header_true_bool:
                     ::std::option::Option::None
--
+                ,
                 header_false_bool:
                     ::std::option::Option::None
--
+                ,
                 header_string_list:
                     ::std::option::Option::None
--
+                ,
                 header_string_set:
                     ::std::option::Option::None
--
+                ,
                 header_integer_list:
                     ::std::option::Option::None
--
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 header_enum:
                     ::std::option::Option::None
--
+                ,
                 header_enum_list:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         Ok(response) };
                                 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());
--
+    }
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderInputs
     #[::tokio::test]
     async fn rest_json_supports_negative_infinity_float_header_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Double", "-Infinity")
             .header("X-Float", "-Infinity")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .input_and_output_with_headers(move |input: crate::input::InputAndOutputWithHeadersInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::InputAndOutputWithHeadersInput {
                 header_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 header_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 header_string:
                     ::std::option::Option::None
--
+                ,
                 header_byte:
                     ::std::option::Option::None
--
+                ,
                 header_short:
                     ::std::option::Option::None
--
+                ,
                 header_integer:
                     ::std::option::Option::None
--
+                ,
                 header_long:
                     ::std::option::Option::None
--
+                ,
                 header_true_bool:
                     ::std::option::Option::None
--
+                ,
                 header_false_bool:
                     ::std::option::Option::None
--
+                ,
                 header_string_list:
                     ::std::option::Option::None
--
+                ,
                 header_string_set:
                     ::std::option::Option::None
--
+                ,
                 header_integer_list:
                     ::std::option::Option::None
--
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 header_enum:
                     ::std::option::Option::None
--
+                ,
                 header_enum_list:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.header_string, expected.header_string, "Unexpected value for `header_string`");
         ::pretty_assertions::assert_eq!(input.header_byte, expected.header_byte, "Unexpected value for `header_byte`");
         ::pretty_assertions::assert_eq!(input.header_short, expected.header_short, "Unexpected value for `header_short`");
         ::pretty_assertions::assert_eq!(input.header_integer, expected.header_integer, "Unexpected value for `header_integer`");
         ::pretty_assertions::assert_eq!(input.header_long, expected.header_long, "Unexpected value for `header_long`");
         assert!(input.header_float.float_equals(&expected.header_float),
                                             "Unexpected value for `header_float` {:?} vs. {:?}", expected.header_float, input.header_float);
         assert!(input.header_double.float_equals(&expected.header_double),
                                             "Unexpected value for `header_double` {:?} vs. {:?}", expected.header_double, input.header_double);
         ::pretty_assertions::assert_eq!(input.header_true_bool, expected.header_true_bool, "Unexpected value for `header_true_bool`");
         ::pretty_assertions::assert_eq!(input.header_false_bool, expected.header_false_bool, "Unexpected value for `header_false_bool`");
         ::pretty_assertions::assert_eq!(input.header_string_list, expected.header_string_list, "Unexpected value for `header_string_list`");
         ::pretty_assertions::assert_eq!(input.header_string_set, expected.header_string_set, "Unexpected value for `header_string_set`");
         ::pretty_assertions::assert_eq!(input.header_integer_list, expected.header_integer_list, "Unexpected value for `header_integer_list`");
         ::pretty_assertions::assert_eq!(input.header_boolean_list, expected.header_boolean_list, "Unexpected value for `header_boolean_list`");
         ::pretty_assertions::assert_eq!(input.header_timestamp_list, expected.header_timestamp_list, "Unexpected value for `header_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.header_enum, expected.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(input.header_enum_list, expected.header_enum_list, "Unexpected value for `header_enum_list`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum, expected.header_integer_enum, "Unexpected value for `header_integer_enum`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum_list, expected.header_integer_enum_list, "Unexpected value for `header_integer_enum_list`");
         let response =
             crate::output::InputAndOutputWithHeadersOutput {
                 header_string:
                     ::std::option::Option::None
--
+                ,
                 header_byte:
                     ::std::option::Option::None
--
+                ,
                 header_short:
                     ::std::option::Option::None
--
+                ,
                 header_integer:
                     ::std::option::Option::None
--
+                ,
                 header_long:
                     ::std::option::Option::None
--
+                ,
                 header_float:
                     ::std::option::Option::None
--
+                ,
                 header_double:
                     ::std::option::Option::None
--
+                ,
                 header_true_bool:
                     ::std::option::Option::None
--
+                ,
                 header_false_bool:
                     ::std::option::Option::None
--
+                ,
                 header_string_list:
                     ::std::option::Option::None
--
+                ,
                 header_string_set:
                     ::std::option::Option::None
--
+                ,
                 header_integer_list:
                     ::std::option::Option::None
--
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
--
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
--
+                ,
                 header_enum:
                     ::std::option::Option::None
--
+                ,
                 header_enum_list:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
--
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         Ok(response) };
                                 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());
--
+    }
     /// Tests responses with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_string_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_string: ::std::option::Option::Some("Hello".to_owned()),
             header_string_list: ::std::option::Option::Some(vec![
                 "a".to_owned(),
                 "b".to_owned(),
                 "c".to_owned(),
             ]),
             header_string_set: ::std::option::Option::Some(
                 vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]
                     .try_into()
                     .expect("this is only used in tests"),
             ),
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-String", "Hello"),
             ("X-StringList", "a, b, c"),
             ("X-StringSet", "a, b, c"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Tests responses with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_quoted_string_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_string_list: ::std::option::Option::Some(vec![
                 "b,c".to_owned(),
                 "\"def\"".to_owned(),
                 "a".to_owned(),
             ]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-StringList", "\"b,c\", \"\\\"def\\\"\", a")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Tests responses with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_numeric_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_byte: ::std::option::Option::Some(1),
             header_short: ::std::option::Option::Some(123),
             header_integer: ::std::option::Option::Some(123),
             header_long: ::std::option::Option::Some(123),
             header_float: ::std::option::Option::Some(1.1_f32),
             header_double: ::std::option::Option::Some(1.1_f64),
             header_integer_list: ::std::option::Option::Some(vec![1, 2, 3]),
             header_string: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Byte", "1"),
             ("X-Double", "1.1"),
             ("X-Float", "1.1"),
             ("X-Integer", "123"),
             ("X-IntegerList", "1, 2, 3"),
             ("X-Long", "123"),
             ("X-Short", "123"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Tests responses with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_boolean_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_true_bool: ::std::option::Option::Some(true),
             header_false_bool: ::std::option::Option::Some(false),
             header_boolean_list: ::std::option::Option::Some(vec![true, false, true]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Boolean1", "true"),
             ("X-Boolean2", "false"),
             ("X-BooleanList", "true, false, true"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Tests responses with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_timestamp_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_timestamp_list: ::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-TimestampList",
             "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT",
         )];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Tests responses with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_enum_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_enum: ::std::option::Option::Some(
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             header_enum_list: ::std::option::Option::Some(vec![
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "Bar"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "Baz"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Enum", "Foo"), ("X-EnumList", "Foo, Bar, Baz")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Tests responses with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     async fn rest_json_input_and_output_with_int_enum_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_integer_enum: ::std::option::Option::Some(1),
             header_integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-IntegerEnum", "1"), ("X-IntegerEnumList", "1, 2, 3")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderOutputs
     #[::tokio::test]
     async fn rest_json_supports_na_n_float_header_outputs_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_float: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             header_double: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Double", "NaN"), ("X-Float", "NaN")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderOutputs
     #[::tokio::test]
     async fn rest_json_supports_infinity_float_header_outputs_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_float: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             header_double: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Double", "Infinity"), ("X-Float", "Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderOutputs
     #[::tokio::test]
     async fn rest_json_supports_negative_infinity_float_header_outputs_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_float: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             header_double: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Double", "-Infinity"), ("X-Float", "-Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_blobs_test {
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     async fn rest_json_json_blobs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonBlobs")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"data\": \"dmFsdWU=\"\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_blobs(move |input: crate::input::JsonBlobsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonBlobsInput {
                             data: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "value",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonBlobsOutput {
                             data: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     async fn rest_json_json_blobs_response() {
         let output = crate::output::JsonBlobsOutput {
             data: ::std::option::Option::Some(::aws_smithy_types::Blob::new("value")),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"data\": \"dmFsdWU=\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_enums_test {
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     async fn rest_json_json_enums_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonEnums")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"fooEnum1\": \"Foo\",\n    \"fooEnum2\": \"0\",\n    \"fooEnum3\": \"1\",\n    \"fooEnumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumSet\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumMap\": {\n        \"hi\": \"Foo\",\n        \"zero\": \"0\"\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_enums(move |input: crate::input::JsonEnumsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonEnumsInput {
                             foo_enum1: ::std::option::Option::Some(
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             foo_enum2: ::std::option::Option::Some(
                                 "0".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             foo_enum3: ::std::option::Option::Some(
                                 "1".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             foo_enum_list: ::std::option::Option::Some(vec![
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "0".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ]),
                             foo_enum_set: ::std::option::Option::Some(
                                 vec![
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                     "0".parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
--
+                                ]
                                 .try_into()
                                 .expect("this is only used in tests"),
                             ),
                             foo_enum_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "hi".to_owned(),
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 );
                                 ret.insert(
                                     "zero".to_owned(),
                                     "0".parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 );
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonEnumsOutput {
                             foo_enum1: ::std::option::Option::None,
                             foo_enum2: ::std::option::Option::None,
                             foo_enum3: ::std::option::Option::None,
                             foo_enum_list: ::std::option::Option::None,
                             foo_enum_set: ::std::option::Option::None,
                             foo_enum_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     async fn rest_json_json_enums_response() {
         let output = crate::output::JsonEnumsOutput {
             foo_enum1: ::std::option::Option::Some(
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             foo_enum2: ::std::option::Option::Some(
                 "0".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             foo_enum3: ::std::option::Option::Some(
                 "1".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             foo_enum_list: ::std::option::Option::Some(vec![
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "0".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ]),
             foo_enum_set: ::std::option::Option::Some(
                 vec![
                     "Foo"
                         .parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
                     "0".parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
--
+                ]
                 .try_into()
                 .expect("this is only used in tests"),
             ),
             foo_enum_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo"
                         .parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
                 );
                 ret
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"fooEnum1\": \"Foo\",\n    \"fooEnum2\": \"0\",\n    \"fooEnum3\": \"1\",\n    \"fooEnumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumSet\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumMap\": {\n        \"hi\": \"Foo\",\n        \"zero\": \"0\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_int_enums_test {
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     async fn rest_json_json_int_enums_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonIntEnums")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_int_enums(move |input: crate::input::JsonIntEnumsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonIntEnumsInput {
                             integer_enum1: ::std::option::Option::Some(1),
                             integer_enum2: ::std::option::Option::Some(2),
                             integer_enum3: ::std::option::Option::Some(3),
                             integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
                             integer_enum_set: ::std::option::Option::Some(
                                 vec![1, 2].try_into().expect("this is only used in tests"),
                             ),
                             integer_enum_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("abc".to_owned(), 1);
                                 ret.insert("def".to_owned(), 2);
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonIntEnumsOutput {
                             integer_enum1: ::std::option::Option::None,
                             integer_enum2: ::std::option::Option::None,
                             integer_enum3: ::std::option::Option::None,
                             integer_enum_list: ::std::option::Option::None,
                             integer_enum_set: ::std::option::Option::None,
                             integer_enum_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     async fn rest_json_json_int_enums_response() {
         let output = crate::output::JsonIntEnumsOutput {
             integer_enum1: ::std::option::Option::Some(1),
             integer_enum2: ::std::option::Option::Some(2),
             integer_enum3: ::std::option::Option::Some(3),
             integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
             integer_enum_set: ::std::option::Option::Some(
                 vec![1, 2].try_into().expect("this is only used in tests"),
             ),
             integer_enum_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), 1);
                 ret.insert("def".to_owned(), 2);
                 ret
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_lists_test {
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     async fn rest_json_lists_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonLists")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\n        }\n    ]\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_lists(move |input: crate::input::JsonListsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonListsInput {
                             string_list: ::std::option::Option::Some(vec![
                                 "foo".to_owned(),
                                 "bar".to_owned(),
                             ]),
                             string_set: ::std::option::Option::Some(
                                 vec!["foo".to_owned(), "bar".to_owned()]
                                     .try_into()
                                     .expect("this is only used in tests"),
                             ),
                             integer_list: ::std::option::Option::Some(vec![1, 2]),
                             boolean_list: ::std::option::Option::Some(vec![true, false]),
                             timestamp_list: ::std::option::Option::Some(vec![
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ]),
                             enum_list: ::std::option::Option::Some(vec![
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "0".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ]),
                             int_enum_list: ::std::option::Option::Some(vec![1, 2]),
                             nested_string_list: ::std::option::Option::Some(vec![
                                 vec!["foo".to_owned(), "bar".to_owned()],
                                 vec!["baz".to_owned(), "qux".to_owned()],
                             ]),
                             structure_list: ::std::option::Option::Some(vec![
                                 crate::model::StructureListMember {
                                     a: ::std::option::Option::Some("1".to_owned()),
                                     b: ::std::option::Option::Some("2".to_owned()),
                                 },
                                 crate::model::StructureListMember {
                                     a: ::std::option::Option::Some("3".to_owned()),
                                     b: ::std::option::Option::Some("4".to_owned()),
                                 },
                             ]),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonListsOutput {
                             string_list: ::std::option::Option::None,
                             string_set: ::std::option::Option::None,
                             integer_list: ::std::option::Option::None,
                             boolean_list: ::std::option::Option::None,
                             timestamp_list: ::std::option::Option::None,
                             enum_list: ::std::option::Option::None,
                             int_enum_list: ::std::option::Option::None,
                             nested_string_list: ::std::option::Option::None,
                             structure_list: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     async fn rest_json_lists_empty_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonLists")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"stringList\": []\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_lists(move |input: crate::input::JsonListsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonListsInput {
                             string_list: ::std::option::Option::Some(vec![]),
                             string_set: ::std::option::Option::None,
                             integer_list: ::std::option::Option::None,
                             boolean_list: ::std::option::Option::None,
                             timestamp_list: ::std::option::Option::None,
                             enum_list: ::std::option::Option::None,
                             int_enum_list: ::std::option::Option::None,
                             nested_string_list: ::std::option::Option::None,
                             structure_list: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonListsOutput {
                             string_list: ::std::option::Option::None,
                             string_set: ::std::option::Option::None,
                             integer_list: ::std::option::Option::None,
                             boolean_list: ::std::option::Option::None,
                             timestamp_list: ::std::option::Option::None,
                             enum_list: ::std::option::Option::None,
                             int_enum_list: ::std::option::Option::None,
                             nested_string_list: ::std::option::Option::None,
                             structure_list: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     async fn rest_json_lists_response() {
         let output = crate::output::JsonListsOutput {
             string_list: ::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]),
             string_set: ::std::option::Option::Some(
                 vec!["foo".to_owned(), "bar".to_owned()]
                     .try_into()
                     .expect("this is only used in tests"),
             ),
             integer_list: ::std::option::Option::Some(vec![1, 2]),
             boolean_list: ::std::option::Option::Some(vec![true, false]),
             timestamp_list: ::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]),
             enum_list: ::std::option::Option::Some(vec![
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "0".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ]),
             int_enum_list: ::std::option::Option::Some(vec![1, 2]),
             nested_string_list: ::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]),
             structure_list: ::std::option::Option::Some(vec![
                 crate::model::StructureListMember {
                     a: ::std::option::Option::Some("1".to_owned()),
                     b: ::std::option::Option::Some("2".to_owned()),
                 },
                 crate::model::StructureListMember {
                     a: ::std::option::Option::Some("3".to_owned()),
                     b: ::std::option::Option::Some("4".to_owned()),
                 },
             ]),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\n        }\n    ]\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     async fn rest_json_lists_empty_response() {
         let output = crate::output::JsonListsOutput {
             string_list: ::std::option::Option::Some(vec![]),
             string_set: ::std::option::Option::None,
             integer_list: ::std::option::Option::None,
             boolean_list: ::std::option::Option::None,
             timestamp_list: ::std::option::Option::None,
             enum_list: ::std::option::Option::None,
             int_enum_list: ::std::option::Option::None,
             nested_string_list: ::std::option::Option::None,
             structure_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringList\": []\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_maps_test {
     /// Serializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     async fn rest_json_json_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_maps(move |input: crate::input::JsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonMapsInput {
                             dense_struct_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "foo".to_owned(),
                                     crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("there".to_owned()),
                                     },
                                 );
                                 ret.insert(
                                     "baz".to_owned(),
                                     crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("bye".to_owned()),
                                     },
                                 );
                                 ret
                             }),
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonMapsOutput {
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInMaps
     #[::tokio::test]
     async fn rest_json_serializes_zero_values_in_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_maps(move |input: crate::input::JsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonMapsInput {
                             dense_number_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), 0);
                                 ret
                             }),
                             dense_boolean_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), false);
                                 ret
                             }),
                             dense_struct_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonMapsOutput {
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// A request that contains a dense map of sets.
     /// Test ID: RestJsonSerializesDenseSetMap
     #[::tokio::test]
     async fn rest_json_serializes_dense_set_map_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_maps(move |input: crate::input::JsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonMapsInput {
                             dense_set_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "x".to_owned(),
                                     vec![].try_into().expect("this is only used in tests"),
                                 );
                                 ret.insert(
                                     "y".to_owned(),
                                     vec!["a".to_owned(), "b".to_owned()]
                                         .try_into()
                                         .expect("this is only used in tests"),
                                 );
                                 ret
                             }),
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonMapsOutput {
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Deserializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     async fn rest_json_json_maps_response() {
         let output = crate::output::JsonMapsOutput {
             dense_struct_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("there".to_owned()),
                     },
                 );
                 ret.insert(
                     "baz".to_owned(),
                     crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("bye".to_owned()),
                     },
                 );
                 ret
             }),
             dense_number_map: ::std::option::Option::None,
             dense_boolean_map: ::std::option::Option::None,
             dense_string_map: ::std::option::Option::None,
             dense_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonDeserializesZeroValuesInMaps
     #[::tokio::test]
     async fn rest_json_deserializes_zero_values_in_maps_response() {
         let output = crate::output::JsonMapsOutput {
             dense_number_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), 0);
                 ret
             }),
             dense_boolean_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), false);
                 ret
             }),
             dense_struct_map: ::std::option::Option::None,
             dense_string_map: ::std::option::Option::None,
             dense_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
     /// A response that contains a dense map of sets.
     /// Test ID: RestJsonDeserializesDenseSetMap
     #[::tokio::test]
     async fn rest_json_deserializes_dense_set_map_response() {
         let output = crate::output::JsonMapsOutput {
             dense_set_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "x".to_owned(),
                     vec![].try_into().expect("this is only used in tests"),
                 );
                 ret.insert(
                     "y".to_owned(),
                     vec!["a".to_owned(), "b".to_owned()]
                         .try_into()
                         .expect("this is only used in tests"),
                 );
                 ret
             }),
             dense_struct_map: ::std::option::Option::None,
             dense_number_map: ::std::option::Option::None,
             dense_boolean_map: ::std::option::Option::None,
             dense_string_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_timestamps_test {
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     async fn rest_json_json_timestamps_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"normal\": 1398796238\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             normal: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_date_time_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             date_time: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_date_time_on_target_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             date_time_on_target: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_epoch_seconds_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"epochSeconds\": 1398796238\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             epoch_seconds: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"epochSecondsOnTarget\": 1398796238\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             epoch_seconds_on_target: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_http_date_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             http_date: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_http_date_on_target_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             http_date_on_target: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     async fn rest_json_json_timestamps_response() {
         let output = crate::output::JsonTimestampsOutput {
             normal: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"normal\": 1398796238\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_date_time_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             date_time: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_date_time_on_target_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             date_time_on_target: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_epoch_seconds_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             epoch_seconds: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"epochSeconds\": 1398796238\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             epoch_seconds_on_target: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"epochSecondsOnTarget\": 1398796238\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_http_date_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             http_date: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     async fn rest_json_json_timestamps_with_http_date_on_target_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             http_date_on_target: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_json_unions_test {
     /// Serializes a string union value
     /// Test ID: RestJsonSerializeStringUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_string_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::StringValue("foo".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a boolean union value
     /// Test ID: RestJsonSerializeBooleanUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_boolean_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::BooleanValue(true),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a number union value
     /// Test ID: RestJsonSerializeNumberUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_number_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::NumberValue(1),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a blob union value
     /// Test ID: RestJsonSerializeBlobUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_blob_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::BlobValue(::aws_smithy_types::Blob::new(
                                     "foo",
                                 )),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a timestamp union value
     /// Test ID: RestJsonSerializeTimestampUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_timestamp_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::TimestampValue(
                                     ::aws_smithy_types::DateTime::from_fractional_secs(
                                         1398796238, 0_f64,
                                     ),
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes an enum union value
     /// Test ID: RestJsonSerializeEnumUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_enum_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::EnumValue(
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a list union value
     /// Test ID: RestJsonSerializeListUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_list_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::ListValue(vec![
                                     "foo".to_owned(),
                                     "bar".to_owned(),
                                 ]),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a map union value
     /// Test ID: RestJsonSerializeMapUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_map_union_value_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonUnions")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(crate::model::MyUnion::MapValue(
--
+                                {
                                     let mut ret = ::std::collections::HashMap::new();
                                     ret.insert("foo".to_owned(), "bar".to_owned());
                                     ret.insert("spam".to_owned(), "eggs".to_owned());
                                     ret
                                 },
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a structure union value
     /// Test ID: RestJsonSerializeStructureUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_structure_union_value_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonUnions")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::StructureValue(
                                     crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("hello".to_owned()),
                                     },
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Serializes a renamed structure union value
     /// Test ID: RestJsonSerializeRenamedStructureUnionValue
     #[::tokio::test]
     async fn rest_json_serialize_renamed_structure_union_value_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonUnions")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"contents\": {\n        \"renamedStructureValue\": {\n            \"salutation\": \"hello!\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::RenamedStructureValue(
                                     crate::model::RenamedGreeting {
                                         salutation: ::std::option::Option::Some(
                                             "hello!".to_owned(),
                                         ),
                                     },
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
--
+    }
     /// Deserializes a string union value
     /// Test ID: RestJsonDeserializeStringUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_string_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::StringValue(
                 "foo".to_owned(),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes a boolean union value
     /// Test ID: RestJsonDeserializeBooleanUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_boolean_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::BooleanValue(true)),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes a number union value
     /// Test ID: RestJsonDeserializeNumberUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_number_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::NumberValue(1)),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes a blob union value
     /// Test ID: RestJsonDeserializeBlobUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_blob_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::BlobValue(
                 ::aws_smithy_types::Blob::new("foo"),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes a timestamp union value
     /// Test ID: RestJsonDeserializeTimestampUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_timestamp_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes an enum union value
     /// Test ID: RestJsonDeserializeEnumUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_enum_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::EnumValue(
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes a list union value
     /// Test ID: RestJsonDeserializeListUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_list_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".to_owned(),
             ])),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
--
+    }
     /// Deserializes a map union value
     /// Test ID: RestJsonDeserializeMapUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_map_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::MapValue({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), "bar".to_owned());
                 ret.insert("spam".to_owned(), "eggs".to_owned());
                 ret
             })),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
     /// Deserializes a structure union value
     /// Test ID: RestJsonDeserializeStructureUnionValue
     #[::tokio::test]
     async fn rest_json_deserialize_structure_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::StructureValue(
                 crate::model::GreetingStruct {
                     hi: ::std::option::Option::Some("hello".to_owned()),
                 },
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_accept_with_body_test {
     /// When there is modeled output, the accept must be application/json
     /// Test ID: RestJsonWithBodyExpectsApplicationJsonAccept
     #[::tokio::test]
     async fn rest_json_with_body_expects_application_json_accept_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedAcceptWithBody")
                 .method("POST")
                 .header("accept", "application/hal+json")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_accept_with_body(move |input: crate::input::MalformedAcceptWithBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedAcceptWithBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_accept_with_generic_string_test {
     /// When there is a payload without a mediaType trait, the accept must match the
     /// implied content type of the shape.
     /// Test ID: RestJsonWithPayloadExpectsImpliedAccept
     #[::tokio::test]
     async fn rest_json_with_payload_expects_implied_accept_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedAcceptWithGenericString")
                 .method("POST")
                 .header("accept", "application/json")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_accept_with_generic_string(move |input: crate::input::MalformedAcceptWithGenericStringInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedAcceptWithGenericStringOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_accept_with_payload_test {
     /// When there is a payload with a mediaType trait, the accept must match.
     /// Test ID: RestJsonWithPayloadExpectsModeledAccept
     #[::tokio::test]
     async fn rest_json_with_payload_expects_modeled_accept_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedAcceptWithPayload")
                 .method("POST")
                 .header("accept", "application/json")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_accept_with_payload(move |input: crate::input::MalformedAcceptWithPayloadInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedAcceptWithPayloadOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(406).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "NotAcceptableException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_blob_test {
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case0
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case0_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : blob }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case1
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case1_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : \"xyz\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case2
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case2_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : \"YmxvYg=\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case3
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case3_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : [98, 108, 11, 98] }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case4
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case4_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"blob\" : [\"b\", \"l\",\"o\",\"b\"] }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case5
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case5_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : 981081198 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case6
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case6_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case7
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case7_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : [][] }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case8
     #[::tokio::test]
     async fn rest_json_body_malformed_blob_invalid_base64_case8_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : -_== }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_boolean_test {
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case0
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case0_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"true\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case1
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case1_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"True\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case2
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case2_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"TRUE\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case3
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case3_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"y\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case4
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case4_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"Y\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case5
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case5_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"yes\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case6
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case6_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"Yes\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case7
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case7_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"YES\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case8
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case8_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"1\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case9
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case9_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"on\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case10
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case10_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"On\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case11
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case11_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"ON\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case12
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case12_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"false\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case13
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case13_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"False\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case14
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case14_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"FALSE\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case15
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case15_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"n\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case16
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case16_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"N\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case17
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case17_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"no\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case18
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case18_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"No\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case19
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case19_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"NO\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case20
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case20_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case0_malformed_request(
     ) {
-2572
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"0\" }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57+00\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2594
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2609
+        }
-2610
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case21
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case1
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case21_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case1_malformed_request(
     ) {
-2618
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"off\" }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57+00Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2640
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2655
+        }
-2656
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case22
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case2
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case22_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case2_malformed_request(
     ) {
-2664
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"Off\" }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2686
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2701
+        }
-2702
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case23
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case3
     #[::tokio::test]
     async fn rest_json_body_boolean_string_coercion_case23_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case3_malformed_request(
     ) {
-2710
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"OFF\" }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T163957\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2732
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2747
+        }
-2748
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case0
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case4
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case4_malformed_request(
     ) {
-2756
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : True }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T163957Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2778
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2793
+        }
-2794
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case1
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case5
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case5_malformed_request(
     ) {
-2802
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : TRUE }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T163957\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2824
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2839
+        }
-2840
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case2
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case6
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case6_malformed_request(
     ) {
-2848
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : y }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T16:39:57Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2870
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2885
+        }
-2886
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case3
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case7
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case7_malformed_request(
     ) {
-2894
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : Y }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T16:39:57\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2916
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2931
+        }
-2932
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case4
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case8
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case8_malformed_request(
     ) {
-2940
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : yes }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-2962
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-2977
+        }
-2978
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case5
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case9
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case9_malformed_request(
     ) {
-2986
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : Yes }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3008
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3023
+        }
-3024
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case6
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case10
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case10_malformed_request(
     ) {
-3032
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : YES }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T1639\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3054
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3069
+        }
-3070
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case7
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case11
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case11_malformed_request(
     ) {
-3078
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : 1 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"1996-12-19T16Z\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3098
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3113
+        }
-3114
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case8
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case12
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case12_malformed_request(
     ) {
-3122
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : on }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"1996-12-19T16\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3142
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3157
+        }
-3158
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case9
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case13
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case13_malformed_request(
     ) {
-3166
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : On }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19 16:39:57Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3188
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3203
+        }
-3204
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case10
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case14
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case14_malformed_request(
     ) {
-3212
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDateTime")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : ON }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"2011-12-03T10:15:30+01:00[Europe/Paris]\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3234
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3249
+        }
-3250
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case11
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyDefaultInput`](crate::input::MalformedTimestampBodyDefaultInput) using modelled bindings.
     pub struct MalformedTimestampBodyDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampBodyDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyDefaultInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDefaultInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_default::de_malformed_timestamp_body_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampBodyDefaultInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDefaultOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyDefaultError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_body_default_test {
-+
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case11_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_date_time_case0_malformed_request() {
-3363
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : False }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50.52Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3385
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3400
+        }
-3401
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case12
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case12_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_date_time_case1_malformed_request() {
-3408
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : FALSE }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50Z\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3430
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3445
+        }
-3446
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case13
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case13_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_date_time_case2_malformed_request() {
-3453
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : n }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57-08:00\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3475
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3490
+        }
-3491
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case14
     /// By default, epoch second timestamps as strings are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsStringifiedEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case14_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_stringified_epoch_seconds_case0_malformed_request(
     ) {
-3499
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : N }".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1515531081.1234\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3521
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3536
+        }
-3537
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case15
     /// By default, epoch second timestamps as strings are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsStringifiedEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case15_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_stringified_epoch_seconds_case1_malformed_request(
     ) {
-3545
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : no }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"1515531081\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3565
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3580
+        }
-3581
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case16
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case16_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case0_malformed_request(
     ) {
-3588
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : No }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3608
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3623
+        }
-3624
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case17
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case17_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case1_malformed_request(
     ) {
-3631
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : NO }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081ABC }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3651
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3666
+        }
-3667
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case18
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case2
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case18_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case2_malformed_request(
     ) {
-3674
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : 0 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3694
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3709
+        }
-3710
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case19
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case3
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case19_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case3_malformed_request(
     ) {
-3717
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : off }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081.123.456 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3737
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3752
+        }
-3753
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case20
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case4
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case20_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case4_malformed_request(
     ) {
-3760
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : Off }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3780
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3795
+        }
-3796
+    }
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case21
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case5
     #[::tokio::test]
     async fn rest_json_body_boolean_bad_literal_case21_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case5_malformed_request(
     ) {
-3803
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : OFF }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3823
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3838
+        }
-3839
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case0
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case6
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case6_malformed_request(
     ) {
-3846
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/True")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3866
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3881
+        }
-3882
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case1
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case7
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case7_malformed_request(
     ) {
-3889
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/TRUE")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"-Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3909
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3924
+        }
-3925
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case2
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case8
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case8_malformed_request(
     ) {
-3932
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/y")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3952
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-3967
+        }
-3968
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case3
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case9
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case9_malformed_request(
     ) {
-3975
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/Y")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"NaN\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-3995
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4010
+        }
-4011
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case4
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_timestamp_default_rejects_http_date_case0_malformed_request() {
-4018
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/yes")
                 .uri("/MalformedTimestampBodyDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"Tue, 29 Apr 2014 18:30:38 GMT\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4040
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4055
+        }
-4056
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case5
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPHEADEREPOCH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderEpochInput`](crate::input::MalformedTimestampHeaderEpochInput) using modelled bindings.
     pub struct MalformedTimestampHeaderEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampHeaderEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderEpochInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderEpochInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADEREPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_epoch::de_malformed_timestamp_header_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampHeaderEpochInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderEpochOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderEpochError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_header_epoch_test {
-+
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_date_time_case0_malformed_request() {
-4169
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/Yes")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50.52Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4187
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4202
+        }
-4203
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case6
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_date_time_case1_malformed_request() {
-4210
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/YES")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4228
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4243
+        }
-4244
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case7
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_date_time_case2_malformed_request() {
-4251
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/1")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57-08:00")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4269
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4284
+        }
-4285
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case8
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_http_date_case0_malformed_request() {
-4292
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/on")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "Tue, 29 Apr 2014 18:30:38 GMT")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4310
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4325
+        }
-4326
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case9
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case0_malformed_request() {
-4332
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/On")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4350
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4365
+        }
-4366
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case10
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case1
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case1_malformed_request() {
-4372
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/ON")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "1515531081ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4390
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4405
+        }
-4406
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case11
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case2
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case11_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case2_malformed_request() {
-4412
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/False")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4430
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4445
+        }
-4446
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case12
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case3
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case12_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case3_malformed_request() {
-4452
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/FALSE")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "1515531081.123.456")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4470
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4485
+        }
-4486
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case13
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case4
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case13_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case4_malformed_request() {
-4492
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/n")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4510
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4525
+        }
-4526
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case14
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case5
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case14_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case5_malformed_request() {
-4532
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/N")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4550
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4565
+        }
-4566
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case15
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case6
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case15_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case6_malformed_request() {
-4572
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/no")
                 .uri("/MalformedTimestampHeaderEpoch")
                 .method("POST")
                 .header("timestamp", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4590
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4605
+        }
-4606
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case16
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case16_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/No")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDATETIME: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderDateTimeInput`](crate::input::MalformedTimestampHeaderDateTimeInput) using modelled bindings.
     pub struct MalformedTimestampHeaderDateTimeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDateTimeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampHeaderDateTimeInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderDateTimeInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDateTimeInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDATETIME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_date_time::de_malformed_timestamp_header_date_time_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampHeaderDateTimeInputFuture {
             inner: Box::pin(fut),
-4672
+        }
-4673
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case17
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case17_malformed_request() {
--
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/NO")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDateTimeOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderDateTimeError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-4705
+        }
-4706
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case18
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_header_date_time_test {
-+
     /// When the format is date-time, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case18_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_http_date_case0_malformed_request() {
-4719
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/0")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "Tue, 29 Apr 2014 18:30:38 GMT")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4737
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4752
+        }
-4753
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case19
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case19_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_epoch_seconds_case0_malformed_request() {
-4760
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/off")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1515531081.1234")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4778
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4793
+        }
-4794
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case20
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case20_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_epoch_seconds_case1_malformed_request() {
-4801
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/Off")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1515531081")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4819
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4834
+        }
-4835
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case21
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case0
     #[::tokio::test]
     async fn rest_json_path_boolean_string_coercion_case21_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case0_malformed_request(
     ) {
-4843
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/OFF")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57+00")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4861
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4876
+        }
-4877
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case0
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case1
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case1_malformed_request(
     ) {
-4885
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57+00Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=True"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4903
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4918
+        }
-4919
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case1
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case2
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case2_malformed_request(
     ) {
-4927
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=TRUE"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4945
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-4960
+        }
-4961
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case2
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case3
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case3_malformed_request(
     ) {
-4969
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T163957")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=y".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-4987
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5002
+        }
-5003
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case3
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case4
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case4_malformed_request(
     ) {
-5011
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "19961219T163957Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=Y".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5029
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5044
+        }
-5045
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case4
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case5
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case5_malformed_request(
     ) {
-5053
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "19961219T163957")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=yes".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5071
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5086
+        }
-5087
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case5
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case6
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case6_malformed_request(
     ) {
-5095
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "19961219T16:39:57Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=Yes".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5113
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5128
+        }
-5129
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case6
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case7
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case7_malformed_request(
     ) {
-5137
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "19961219T16:39:57")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=YES".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5155
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5170
+        }
-5171
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case7
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case8
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case8_malformed_request(
     ) {
-5179
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=1".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5197
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5212
+        }
-5213
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case8
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case9
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case9_malformed_request(
     ) {
-5221
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=on".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5239
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5254
+        }
-5255
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case9
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case10
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case10_malformed_request(
     ) {
-5263
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T1639")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=On".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5281
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5296
+        }
-5297
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case10
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case11
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case11_malformed_request(
     ) {
-5305
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=ON".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5323
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5338
+        }
-5339
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case11
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case12
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case11_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case12_malformed_request(
     ) {
-5347
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=False"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5365
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5380
+        }
-5381
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case12
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case13
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case12_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case13_malformed_request(
     ) {
-5389
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "1996-12-19 16:39:57Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=FALSE"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5407
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5422
+        }
-5423
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case13
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case14
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case13_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case14_malformed_request(
     ) {
-5431
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDateTime")
                 .method("POST")
                 .header("timestamp", "2011-12-03T10:15:30+01:00[Europe/Paris]")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=n".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5449
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5464
+        }
-5465
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case14
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderDefaultInput`](crate::input::MalformedTimestampHeaderDefaultInput) using modelled bindings.
     pub struct MalformedTimestampHeaderDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampHeaderDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderDefaultInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDefaultInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_default::de_malformed_timestamp_header_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampHeaderDefaultInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDefaultOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderDefaultError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_header_default_test {
-+
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case14_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_default_rejects_date_time_case0_malformed_request() {
-5578
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDefault")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50.52Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=N".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5596
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5611
+        }
-5612
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case15
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case15_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_default_rejects_date_time_case1_malformed_request() {
-5619
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDefault")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=no".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5637
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5652
+        }
-5653
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case16
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case16_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_default_rejects_date_time_case2_malformed_request() {
-5660
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDefault")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57-08:00")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=No".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5678
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5693
+        }
-5694
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case17
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case17_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_default_rejects_epoch_seconds_case0_malformed_request() {
-5701
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDefault")
                 .method("POST")
                 .header("timestamp", "1515531081.1234")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=NO".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5719
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5734
+        }
-5735
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case18
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case18_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_timestamp_default_rejects_epoch_seconds_case1_malformed_request() {
-5742
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampHeaderDefault")
                 .method("POST")
                 .header("timestamp", "1515531081")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=0".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5760
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5775
+        }
-5776
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case19
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYEPOCH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryEpochInput`](crate::input::MalformedTimestampQueryEpochInput) using modelled bindings.
     pub struct MalformedTimestampQueryEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampQueryEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryEpochInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryEpochInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYEPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_epoch::de_malformed_timestamp_query_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampQueryEpochInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryEpochOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryEpochError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_query_epoch_test {
-+
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case19_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_date_time_case0_malformed_request() {
-5889
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=off".parse().unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryEpoch?timestamp=1985-04-12T23%3A20%3A50.52Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5910
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5925
+        }
-5926
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case20
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case20_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_date_time_case1_malformed_request() {
-5933
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=Off".parse().unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryEpoch?timestamp=1985-04-12T23%3A20%3A50Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5954
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-5969
+        }
-5970
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case21
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_query_boolean_string_coercion_case21_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_date_time_case2_malformed_request() {
-5977
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=OFF".parse().unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryEpoch?timestamp=1996-12-19T16%3A39%3A57-08%3A00"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-5998
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6013
+        }
-6014
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case0
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_http_date_case0_malformed_request() {
-6021
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "True")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6039
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6054
+        }
-6055
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case1
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsHttpDate_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_http_date_case1_malformed_request() {
-6062
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "TRUE")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6080
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6095
+        }
-6096
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case2
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case0_malformed_request() {
-6102
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "y")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=true"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6122
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6137
+        }
-6138
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case3
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case1_malformed_request() {
-6144
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "Y")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=1515531081ABC"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6164
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6179
+        }
-6180
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case4
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case2
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case2_malformed_request() {
-6186
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "yes")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=0x42"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6206
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6221
+        }
-6222
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case5
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case3
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case3_malformed_request() {
-6228
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "Yes")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=1515531081.123.456"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6248
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6263
+        }
-6264
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case6
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case4
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case4_malformed_request() {
-6270
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "YES")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6290
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6305
+        }
-6306
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case7
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case5
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case5_malformed_request() {
-6312
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "1")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=-Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6332
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6347
+        }
-6348
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case8
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case6
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case6_malformed_request() {
-6354
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryEpoch")
                 .method("POST")
                 .header("booleanInHeader", "on")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=NaN"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6374
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6389
+        }
-6390
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case9
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYHTTPDATE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryHttpDateInput`](crate::input::MalformedTimestampQueryHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampQueryHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampQueryHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryHttpDateInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryHttpDateInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_http_date::de_malformed_timestamp_query_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampQueryHttpDateInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryHttpDateOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryHttpDateError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_query_http_date_test {
-+
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_http_date_rejects_date_time_case0_malformed_request() {
-6503
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryHttpDate")
                 .method("POST")
                 .header("booleanInHeader", "On")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryHttpDate?timestamp=1985-04-12T23%3A20%3A50.52Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6524
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6539
+        }
-6540
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case10
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_http_date_rejects_date_time_case1_malformed_request() {
-6547
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryHttpDate")
                 .method("POST")
                 .header("booleanInHeader", "ON")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryHttpDate?timestamp=1985-04-12T23%3A20%3A50Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6568
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6583
+        }
-6584
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case11
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case11_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_http_date_rejects_date_time_case2_malformed_request() {
-6591
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryHttpDate")
                 .method("POST")
                 .header("booleanInHeader", "False")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryHttpDate?timestamp=1996-12-19T16%3A39%3A57-08%3A00"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6612
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6627
+        }
-6628
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case12
     /// When the format is http-date, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case12_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_http_date_rejects_epoch_seconds_case0_malformed_request() {
-6635
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryHttpDate")
                 .method("POST")
                 .header("booleanInHeader", "FALSE")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryHttpDate?timestamp=1515531081.1234"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6655
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6670
+        }
-6671
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case13
     /// When the format is http-date, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case13_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_http_date_rejects_epoch_seconds_case1_malformed_request() {
-6678
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryHttpDate")
                 .method("POST")
                 .header("booleanInHeader", "n")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryHttpDate?timestamp=1515531081"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6698
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6713
+        }
-6714
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case14
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryDefaultInput`](crate::input::MalformedTimestampQueryDefaultInput) using modelled bindings.
     pub struct MalformedTimestampQueryDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampQueryDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryDefaultInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryDefaultInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_default::de_malformed_timestamp_query_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampQueryDefaultInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryDefaultOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryDefaultError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_query_default_test {
-+
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case14_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_http_date_case0_malformed_request() {
-6827
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "N")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6845
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6860
+        }
-6861
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case15
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsHttpDate_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case15_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_http_date_case1_malformed_request() {
-6868
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "no")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6886
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6901
+        }
-6902
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case16
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case16_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_epoch_seconds_case0_malformed_request() {
-6909
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "No")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1515531081.1234"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6929
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6944
+        }
-6945
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case17
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case17_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_epoch_seconds_case1_malformed_request() {
-6952
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "NO")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1515531081"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-6972
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-6987
+        }
-6988
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case18
     /// UTC offsets must be rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsUTCOffsets
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case18_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_utc_offsets_malformed_request() {
-6995
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "0")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=$value:L"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7015
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7030
+        }
-7031
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case19
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case0
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case19_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case0_malformed_request(
     ) {
-7039
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "off")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39:57+00"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7060
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7075
+        }
-7076
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case20
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case1
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case20_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case1_malformed_request(
     ) {
-7084
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "Off")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39:57+00Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7105
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7120
+        }
-7121
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case21
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case2
     #[::tokio::test]
     async fn rest_json_header_boolean_string_coercion_case21_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case2_malformed_request(
     ) {
-7129
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("booleanInHeader", "OFF")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39:57"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7150
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7165
+        }
-7166
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_byte_test {
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case0
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case3
     #[::tokio::test]
     async fn rest_json_body_byte_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case3_malformed_request(
     ) {
-7174
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 256 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T163957"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7194
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7209
+        }
-7210
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case1
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case4
     #[::tokio::test]
     async fn rest_json_body_byte_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case4_malformed_request(
     ) {
-7218
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : -256 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=19961219T163957Z"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7238
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7253
+        }
-7254
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case2
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case5
     #[::tokio::test]
     async fn rest_json_body_byte_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case5_malformed_request(
     ) {
-7262
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"byteInBody\" : -9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=19961219T163957"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7282
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7297
+        }
-7298
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case3
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case6
     #[::tokio::test]
     async fn rest_json_body_byte_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case6_malformed_request(
     ) {
-7306
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"byteInBody\" : 9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=19961219T16:39:57Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7327
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7342
+        }
-7343
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case4
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case7
     #[::tokio::test]
     async fn rest_json_body_byte_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case7_malformed_request(
     ) {
-7351
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"byteInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=19961219T16:39:57"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7371
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7386
+        }
-7387
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case0
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case8
     #[::tokio::test]
     async fn rest_json_path_byte_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case8_malformed_request(
     ) {
-7395
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/256")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39Z"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7415
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7430
+        }
-7431
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case1
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case9
     #[::tokio::test]
     async fn rest_json_path_byte_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case9_malformed_request(
     ) {
-7439
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/-256")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7459
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7474
+        }
-7475
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case2
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case10
     #[::tokio::test]
     async fn rest_json_path_byte_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case10_malformed_request(
     ) {
-7483
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/-9223372000000000000")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T1639"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7503
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7518
+        }
-7519
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case3
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case11
     #[::tokio::test]
     async fn rest_json_path_byte_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case11_malformed_request(
     ) {
-7527
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/9223372000000000000")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16Z"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7547
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7562
+        }
-7563
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case4
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case12
     #[::tokio::test]
     async fn rest_json_path_byte_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case12_malformed_request(
     ) {
-7571
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/123000000000000000000000")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7591
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7606
+        }
-7607
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case0
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case13
     #[::tokio::test]
     async fn rest_json_query_byte_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case13_malformed_request(
     ) {
-7615
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=256".parse().unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19%2016:39:57Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7636
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7651
+        }
-7652
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case1
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case14
     #[::tokio::test]
     async fn rest_json_query_byte_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case14_malformed_request(
     ) {
-7660
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampQueryDefault")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=-256".parse().unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=2011-12-03T10:15:30+01:00[Europe/Paris]"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7681
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7696
+        }
-7697
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case2
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPPATHEPOCH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathEpochInput`](crate::input::MalformedTimestampPathEpochInput) using modelled bindings.
     pub struct MalformedTimestampPathEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampPathEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathEpochInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathEpochInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHEPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_epoch::de_malformed_timestamp_path_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampPathEpochInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathEpochOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathEpochError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_path_epoch_test {
-+
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_query_byte_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_date_time_case0_malformed_request() {
-7810
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/1985-04-12T23%3A20%3A50.52Z")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=-9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7827
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7842
+        }
-7843
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case3
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_query_byte_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_date_time_case1_malformed_request() {
-7850
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/1985-04-12T23%3A20%3A50Z")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7867
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7882
+        }
-7883
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case4
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_query_byte_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_date_time_case2_malformed_request() {
-7890
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/1996-12-19T16%3A39%3A57-08%3A00")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=123000000000000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7907
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7922
+        }
-7923
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case0
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_header_byte_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_http_date_case0_malformed_request() {
-7930
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT")
                 .method("POST")
                 .header("byteInHeader", "256")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7947
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-7962
+        }
-7963
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case1
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsHttpDate_case1
     #[::tokio::test]
     async fn rest_json_header_byte_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_http_date_case1_malformed_request() {
-7970
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "-256")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
                         let mut http_request = http::Request::builder()
                             .uri("/MalformedTimestampPathEpoch/Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT")
                             .method("POST")
             .body(::aws_smithy_http_server::body::Body::empty()).unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-7986
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8001
+        }
-8002
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case2
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case0
     #[::tokio::test]
     async fn rest_json_header_byte_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case0_malformed_request() {
-8008
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/true")
                 .method("POST")
                 .header("byteInHeader", "-9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8025
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8040
+        }
-8041
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case3
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case1
     #[::tokio::test]
     async fn rest_json_header_byte_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case1_malformed_request() {
-8047
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/1515531081ABC")
                 .method("POST")
                 .header("byteInHeader", "9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8064
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8079
+        }
-8080
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case4
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case2
     #[::tokio::test]
     async fn rest_json_header_byte_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case2_malformed_request() {
-8086
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/0x42")
                 .method("POST")
                 .header("byteInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8103
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8118
+        }
-8119
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case0
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case3
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case3_malformed_request() {
-8125
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/1515531081.123.456")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"123\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8142
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8157
+        }
-8158
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case1
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case4
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case4_malformed_request() {
-8164
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : true }".as_bytes()),
                 ))
                 .uri("/MalformedTimestampPathEpoch/Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8181
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8196
+        }
-8197
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case2
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case5
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case5_malformed_request() {
-8203
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/-Infinity")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 1.001 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8220
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8235
+        }
-8236
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case3
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case6
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case6_malformed_request() {
-8242
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathEpoch/NaN")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 2ABC }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8259
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8274
+        }
-8275
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case4
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPPATHHTTPDATE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathHttpDateInput`](crate::input::MalformedTimestampPathHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampPathHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampPathHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathHttpDateInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathHttpDateInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_http_date::de_malformed_timestamp_path_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampPathHttpDateInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathHttpDateOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathHttpDateError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_path_http_date_test {
-+
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsDateTime_case0
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_http_date_rejects_date_time_case0_malformed_request() {
-8388
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathHttpDate/1985-04-12T23%3A20%3A50.52Z")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 0x42 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8405
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8420
+        }
-8421
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case5
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsDateTime_case1
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_http_date_rejects_date_time_case1_malformed_request() {
-8428
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathHttpDate/1985-04-12T23%3A20%3A50Z")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8445
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8460
+        }
-8461
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case6
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsDateTime_case2
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_http_date_rejects_date_time_case2_malformed_request() {
-8468
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathHttpDate/1996-12-19T16%3A39%3A57-08%3A00")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"Infinity\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8485
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8500
+        }
-8501
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case7
     /// When the format is http-date,  epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_http_date_rejects_epoch_seconds_case0_malformed_request() {
-8508
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathHttpDate/1515531081.1234")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : -Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8525
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8540
+        }
-8541
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case8
     /// When the format is http-date,  epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_http_date_rejects_epoch_seconds_case1_malformed_request() {
-8548
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathHttpDate/1515531081")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8565
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8580
+        }
-8581
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case9
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDTIMESTAMPPATHDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathDefaultInput`](crate::input::MalformedTimestampPathDefaultInput) using modelled bindings.
     pub struct MalformedTimestampPathDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedTimestampPathDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathDefaultInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathDefaultInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_default::de_malformed_timestamp_path_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedTimestampPathDefaultInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathDefaultOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathDefaultError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_timestamp_path_default_test {
-+
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsHttpDate_case0
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_http_date_case0_malformed_request() {
-8694
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : NaN }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8711
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8726
+        }
-8727
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case10
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsHttpDate_case1
     #[::tokio::test]
     async fn rest_json_body_byte_malformed_value_rejected_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_http_date_case1_malformed_request() {
-8734
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .unwrap();
                         let mut http_request = http::Request::builder()
                             .uri("/MalformedTimestampPathDefault/Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT")
                             .method("POST")
             .body(::aws_smithy_http_server::body::Body::empty()).unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8750
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8765
+        }
-8766
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case0
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsEpochSeconds_case0
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_epoch_seconds_case0_malformed_request() {
-8773
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/true")
                 .uri("/MalformedTimestampPathDefault/1515531081.1234")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8790
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8805
+        }
-8806
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case1
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsEpochSeconds_case1
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_epoch_seconds_case1_malformed_request() {
-8813
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1.001")
                 .uri("/MalformedTimestampPathDefault/1515531081")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8830
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8845
+        }
-8846
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case2
     /// UTC offsets must be rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsUTCOffsets
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_utc_offsets_malformed_request() {
-8853
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/2ABC")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57-08%3A00")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8870
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8885
+        }
-8886
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case3
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case0
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case0_malformed_request(
     ) {
-8894
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/0x42")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57%2B00")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8911
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8926
+        }
-8927
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case4
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case1
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case1_malformed_request(
     ) {
-8935
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/Infinity")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57%2B00Z")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8952
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-8967
+        }
-8968
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case5
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case2
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case2_malformed_request(
     ) {
-8976
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/-Infinity")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-8993
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9008
+        }
-9009
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case6
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case3
     #[::tokio::test]
     async fn rest_json_path_byte_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case3_malformed_request(
     ) {
-9017
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/NaN")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T163957")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9034
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9049
+        }
-9050
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case0
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case4
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case4_malformed_request(
     ) {
-9058
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/19961219T163957Z")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9075
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9090
+        }
-9091
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case1
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case5
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case5_malformed_request(
     ) {
-9099
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/19961219T163957")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9116
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9131
+        }
-9132
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case2
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case6
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case6_malformed_request(
     ) {
-9140
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/19961219T16%3A39%3A57Z")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9157
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9172
+        }
-9173
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case3
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case7
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case7_malformed_request(
     ) {
-9181
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/19961219T16%3A39%3A57")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9198
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9213
+        }
-9214
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case4
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case8
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case8_malformed_request(
     ) {
-9222
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39Z")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9239
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9254
+        }
-9255
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case5
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case9
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case9_malformed_request(
     ) {
-9263
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=-Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9280
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9295
+        }
-9296
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case6
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case10
     #[::tokio::test]
     async fn rest_json_query_byte_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case10_malformed_request(
     ) {
-9304
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T1639")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9321
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9336
+        }
-9337
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case0
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case11
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case11_malformed_request(
     ) {
-9345
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16Z")
                 .method("POST")
                 .header("byteInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9362
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9377
+        }
-9378
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case1
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case12
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case12_malformed_request(
     ) {
-9386
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16")
                 .method("POST")
                 .header("byteInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9403
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9418
+        }
-9419
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case2
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case13
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case13_malformed_request(
     ) {
-9427
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedTimestampPathDefault/1996-12-19%2016%3A39%3A57Z")
                 .method("POST")
                 .header("byteInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9444
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9459
+        }
-9460
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case3
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case14
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case14_malformed_request(
     ) {
-9468
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
                         let mut http_request = http::Request::builder()
                             .uri("/MalformedTimestampPathDefault/2011-12-03T10%3A15%3A30%2B01%3A00%5BEurope%2FParis%5D")
                             .method("POST")
             .body(::aws_smithy_http_server::body::Body::empty()).unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9484
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9499
+        }
-9500
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case4
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedStringInput`](crate::input::MalformedStringInput) using modelled bindings.
     pub struct MalformedStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedStringInputFuture {
     type Output = Result<
         crate::input::MalformedStringInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedStringInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_string::de_malformed_string_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedStringInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedStringOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_string::ser_malformed_string_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_string_test {
-+
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case0
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case0_malformed_request() {
-9598
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedString")
                 .method("POST")
                 .header("byteInHeader", "Infinity")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "xyz")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9617
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9632
+        }
-9633
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case5
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case1
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case1_malformed_request() {
-9641
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedString")
                 .method("POST")
                 .header("byteInHeader", "-Infinity")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "YmxvYg=")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9660
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9675
+        }
-9676
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case6
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case2
     #[::tokio::test]
     async fn rest_json_header_byte_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case2_malformed_request() {
-9684
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedByte/1")
                 .uri("/MalformedString")
                 .method("POST")
                 .header("byteInHeader", "NaN")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "[][]")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9703
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9718
+        }
-9719
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_content_type_with_body_test {
     /// When there is modeled input, they content type must be application/json
     /// Test ID: RestJsonWithBodyExpectsApplicationJsonContentType
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case3
     #[::tokio::test]
     async fn rest_json_with_body_expects_application_json_content_type_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case3_malformed_request() {
-9727
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithBody")
                 .uri("/MalformedString")
                 .method("POST")
                 .header("content-type", "application/hal+json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                 ))
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "-_==")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_with_body(move |input: crate::input::MalformedContentTypeWithBodyInput| {
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9746
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9761
+        }
-9762
+    }
-9763
+}
 #[cfg(test)]
-+
 const CONTENT_TYPE_MALFORMEDDOUBLE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedDoubleInput`](crate::input::MalformedDoubleInput) using modelled bindings.
     pub struct MalformedDoubleInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedDoubleInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedDoubleInputFuture {
     type Output = Result<
         crate::input::MalformedDoubleInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedDoubleInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedDoubleInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDDOUBLE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_double::de_malformed_double_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedDoubleInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedDoubleOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedDoubleError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_error(&self)
-+
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_content_type_without_body_test {
     /// When there is no modeled input, content type must not be set and the body must be empty.
     /// Test ID: RestJsonWithoutBodyExpectsEmptyContentType
 #[cfg(test)]
 mod malformed_double_test {
-+
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_without_body_expects_empty_content_type_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case0_malformed_request() {
-9879
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithoutBody")
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : \"123\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_without_body(move |input: crate::input::MalformedContentTypeWithoutBodyInput| {
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithoutBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9899
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9914
+        }
-9915
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_content_type_with_payload_test {
     /// When there is a payload with a mediaType trait, the content type must match.
     /// Test ID: RestJsonWithPayloadExpectsModeledContentType
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_with_payload_expects_modeled_content_type_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case1_malformed_request() {
-9921
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithPayload")
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_with_payload(move |input: crate::input::MalformedContentTypeWithPayloadInput| {
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithPayloadOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9941
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9956
+        }
-9957
+    }
     /// When there is a payload without a mediaType trait, the content type must match the
     /// implied content type of the shape.
     /// Test ID: RestJsonWithPayloadExpectsImpliedContentType
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_with_payload_expects_implied_content_type_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case2_malformed_request() {
-9963
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedContentTypeWithPayload")
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{}".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : 2ABC }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_content_type_with_payload(move |input: crate::input::MalformedContentTypeWithPayloadInput| {
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedContentTypeWithPayloadOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-9983
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(415).expect("invalid expected HTTP status code"),
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "UnsupportedMediaTypeException")];
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-9998
+        }
-9999
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_double_test {
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case0
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case3_malformed_request() {
-10005
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : \"123\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10025
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10040
+        }
-10041
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case1
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case4_malformed_request() {
-10047
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : true }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10067
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10082
+        }
-10083
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case2
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case5_malformed_request() {
-10089
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : 2ABC }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10109
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10124
+        }
-10125
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case3
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_double_malformed_value_rejected_case6_malformed_request() {
-10131
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : 0x42 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10151
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10166
+        }
-10167
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case4
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathDoubleMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_double_malformed_value_rejected_case0_malformed_request() {
-10173
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .uri("/MalformedDouble/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10190
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10205
+        }
-10206
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case5
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathDoubleMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_double_malformed_value_rejected_case1_malformed_request() {
-10212
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .uri("/MalformedDouble/2ABC")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : -Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10229
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10244
+        }
-10245
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyDoubleMalformedValueRejected_case6
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathDoubleMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_body_double_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_double_malformed_value_rejected_case2_malformed_request() {
-10251
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .uri("/MalformedDouble/0x42")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"doubleInBody\" : NaN }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10268
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10283
+        }
-10284
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathDoubleMalformedValueRejected_case0
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryDoubleMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_path_double_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_double_malformed_value_rejected_case0_malformed_request() {
-10290
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/true")
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedDouble/1?doubleInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10308
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10323
+        }
-10324
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathDoubleMalformedValueRejected_case1
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryDoubleMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_path_double_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_double_malformed_value_rejected_case1_malformed_request() {
-10330
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/2ABC")
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedDouble/1?doubleInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10348
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10363
+        }
-10364
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathDoubleMalformedValueRejected_case2
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryDoubleMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_path_double_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_double_malformed_value_rejected_case2_malformed_request() {
-10370
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/0x42")
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedDouble/1?doubleInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10388
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10403
+        }
-10404
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryDoubleMalformedValueRejected_case0
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderDoubleMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_double_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_double_malformed_value_rejected_case0_malformed_request() {
-10410
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("doubleInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedDouble/1?doubleInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10428
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10443
+        }
-10444
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryDoubleMalformedValueRejected_case1
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderDoubleMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_double_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_double_malformed_value_rejected_case1_malformed_request() {
-10450
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("doubleInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedDouble/1?doubleInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10468
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10483
+        }
-10484
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryDoubleMalformedValueRejected_case2
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderDoubleMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_double_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_double_malformed_value_rejected_case2_malformed_request() {
-10490
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .method("POST")
                 .header("doubleInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedDouble/1?doubleInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10508
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10523
+        }
-10524
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderDoubleMalformedValueRejected_case0
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDFLOAT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedFloatInput`](crate::input::MalformedFloatInput) using modelled bindings.
     pub struct MalformedFloatInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedFloatInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedFloatInputFuture {
     type Output = Result<
         crate::input::MalformedFloatInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedFloatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedFloatInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDFLOAT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_float::de_malformed_float_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedFloatInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedFloatOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_response(self)
-+
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedFloatError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_float_test {
-+
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_header_double_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case0_malformed_request() {
-10639
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("doubleInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : \"123\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10659
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10674
+        }
-10675
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderDoubleMalformedValueRejected_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_header_double_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case1_malformed_request() {
-10681
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("doubleInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10701
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10716
+        }
-10717
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderDoubleMalformedValueRejected_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_header_double_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case2_malformed_request() {
-10723
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedDouble/1")
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("doubleInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : 2ABC }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_double(move |input: crate::input::MalformedDoubleInput| {
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedDoubleOutput, crate::error::MalformedDoubleError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10743
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10758
+        }
-10759
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_float_test {
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case0
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case3_malformed_request() {
-10765
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : \"123\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10785
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10800
+        }
-10801
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case1
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case4_malformed_request() {
-10807
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : true }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10827
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10842
+        }
-10843
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case2
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case5_malformed_request() {
-10849
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : 2ABC }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10869
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10884
+        }
-10885
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case3
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_float_malformed_value_rejected_case6_malformed_request() {
-10891
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : 0x42 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10911
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10926
+        }
-10927
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case4
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathFloatMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_float_malformed_value_rejected_case0_malformed_request() {
-10933
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .uri("/MalformedFloat/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10950
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-10965
+        }
-10966
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case5
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathFloatMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_float_malformed_value_rejected_case1_malformed_request() {
-10972
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .uri("/MalformedFloat/2ABC")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : -Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-10989
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11004
+        }
-11005
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyFloatMalformedValueRejected_case6
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathFloatMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_body_float_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_float_malformed_value_rejected_case2_malformed_request() {
-11011
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .uri("/MalformedFloat/0x42")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"floatInBody\" : NaN }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11028
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11043
+        }
-11044
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathFloatMalformedValueRejected_case0
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryFloatMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_path_float_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_float_malformed_value_rejected_case0_malformed_request() {
-11050
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/true")
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedFloat/1?floatInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11068
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11083
+        }
-11084
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathFloatMalformedValueRejected_case1
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryFloatMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_path_float_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_float_malformed_value_rejected_case1_malformed_request() {
-11090
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/2ABC")
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedFloat/1?floatInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11108
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11123
+        }
-11124
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathFloatMalformedValueRejected_case2
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryFloatMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_path_float_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_float_malformed_value_rejected_case2_malformed_request() {
-11130
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/0x42")
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedFloat/1?floatInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11148
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11163
+        }
-11164
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryFloatMalformedValueRejected_case0
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderFloatMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_float_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_float_malformed_value_rejected_case0_malformed_request() {
-11170
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("floatInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedFloat/1?floatInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11188
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11203
+        }
-11204
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryFloatMalformedValueRejected_case1
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderFloatMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_float_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_float_malformed_value_rejected_case1_malformed_request() {
-11210
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("floatInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedFloat/1?floatInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11228
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11243
+        }
-11244
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryFloatMalformedValueRejected_case2
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderFloatMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_float_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_float_malformed_value_rejected_case2_malformed_request() {
-11250
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .method("POST")
                 .header("floatInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedFloat/1?floatInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11268
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11283
+        }
-11284
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderFloatMalformedValueRejected_case0
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDLONG: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedLongInput`](crate::input::MalformedLongInput) using modelled bindings.
     pub struct MalformedLongInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedLongInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedLongInputFuture {
     type Output = Result<
         crate::input::MalformedLongInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLongInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLongInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLONG,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_long::de_malformed_long_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedLongInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLongOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedLongError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_long_test {
-+
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyLongUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_header_float_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_underflow_overflow_case0_malformed_request() {
-11398
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("floatInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"longInBody\" : -184467440737095500000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11420
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11435
+        }
-11436
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderFloatMalformedValueRejected_case1
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyLongUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_header_float_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_underflow_overflow_case1_malformed_request() {
-11442
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("floatInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"longInBody\" : 184467440737095500000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11464
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11479
+        }
-11480
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderFloatMalformedValueRejected_case2
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyLongUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_header_float_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_underflow_overflow_case2_malformed_request() {
-11486
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedFloat/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("floatInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"longInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_float(move |input: crate::input::MalformedFloatInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedFloatOutput, crate::error::MalformedFloatError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11508
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11523
+        }
-11524
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_integer_test {
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyIntegerUnderflowOverflow_case0
     /// Test ID: RestJsonPathLongUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_body_integer_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_underflow_overflow_case0_malformed_request() {
-11530
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/-184467440737095500000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"integerInBody\" : -9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11547
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11562
+        }
-11563
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyIntegerUnderflowOverflow_case1
     /// Test ID: RestJsonPathLongUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_body_integer_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_underflow_overflow_case1_malformed_request() {
-11569
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/184467440737095500000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"integerInBody\" : 9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11586
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11601
+        }
-11602
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyIntegerUnderflowOverflow_case2
     /// Test ID: RestJsonPathLongUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_body_integer_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_underflow_overflow_case2_malformed_request() {
-11608
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/123000000000000000000000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"integerInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11625
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11640
+        }
-11641
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathIntegerUnderflowOverflow_case0
     /// Test ID: RestJsonQueryLongUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_path_integer_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_underflow_overflow_case0_malformed_request() {
-11647
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/-9223372000000000000")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=-184467440737095500000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11667
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11682
+        }
-11683
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathIntegerUnderflowOverflow_case1
     /// Test ID: RestJsonQueryLongUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_path_integer_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_underflow_overflow_case1_malformed_request() {
-11689
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/9223372000000000000")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=184467440737095500000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11709
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11724
+        }
-11725
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathIntegerUnderflowOverflow_case2
     /// Test ID: RestJsonQueryLongUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_path_integer_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_underflow_overflow_case2_malformed_request() {
-11731
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/123000000000000000000000")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=123000000000000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11751
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11766
+        }
-11767
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryIntegerUnderflowOverflow_case0
     /// Test ID: RestJsonHeaderLongUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_query_integer_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_underflow_overflow_case0_malformed_request() {
-11773
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("longInHeader", "-184467440737095500000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=-9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11791
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11806
+        }
-11807
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryIntegerUnderflowOverflow_case1
     /// Test ID: RestJsonHeaderLongUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_query_integer_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_underflow_overflow_case1_malformed_request() {
-11813
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("longInHeader", "184467440737095500000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11831
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11846
+        }
-11847
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryIntegerUnderflowOverflow_case2
     /// Test ID: RestJsonHeaderLongUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_query_integer_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_underflow_overflow_case2_malformed_request() {
-11853
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("longInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=123000000000000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11871
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11886
+        }
-11887
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderIntegerUnderflowOverflow_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_header_integer_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case0_malformed_request() {
-11893
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "-9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"123\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11913
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11928
+        }
-11929
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderIntegerUnderflowOverflow_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_header_integer_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case1_malformed_request() {
-11935
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11955
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-11970
+        }
-11971
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderIntegerUnderflowOverflow_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_header_integer_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case2_malformed_request() {
-11977
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : 1.001 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-11997
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12012
+        }
-12013
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case0
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case3_malformed_request() {
-12019
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"123\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : 2ABC }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12039
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12054
+        }
-12055
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case1
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case4_malformed_request() {
-12061
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : true }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12081
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12096
+        }
-12097
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case2
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case5_malformed_request() {
-12103
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : 1.001 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12123
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12138
+        }
-12139
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case3
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case6_malformed_request() {
-12145
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : 2ABC }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12165
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12180
+        }
-12181
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case4
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case7
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case7_malformed_request() {
-12187
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : 0x42 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12207
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12222
+        }
-12223
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case5
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case8
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case8_malformed_request() {
-12229
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : Infinity }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12249
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12264
+        }
-12265
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case6
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case9
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case9_malformed_request() {
-12271
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"Infinity\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12291
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12306
+        }
-12307
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case7
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case10
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_long_malformed_value_rejected_case10_malformed_request() {
-12313
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : -Infinity }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12333
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12348
+        }
-12349
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case8
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case0_malformed_request() {
-12355
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12372
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12387
+        }
-12388
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case9
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case1_malformed_request() {
-12394
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1.001")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : NaN }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12411
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12426
+        }
-12427
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case10
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_body_integer_malformed_value_rejected_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case2_malformed_request() {
-12433
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/2ABC")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12450
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12465
+        }
-12466
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case0
     /// Test ID: RestJsonPathLongMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case3_malformed_request() {
-12472
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/true")
                 .uri("/MalformedLong/0x42")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12489
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12504
+        }
-12505
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case1
     /// Test ID: RestJsonPathLongMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case4_malformed_request() {
-12511
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1.001")
                 .uri("/MalformedLong/Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12528
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12543
+        }
-12544
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case2
     /// Test ID: RestJsonPathLongMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case5_malformed_request() {
-12550
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/2ABC")
                 .uri("/MalformedLong/-Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12567
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12582
+        }
-12583
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case3
     /// Test ID: RestJsonPathLongMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_long_malformed_value_rejected_case6_malformed_request() {
-12589
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/0x42")
                 .uri("/MalformedLong/NaN")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12606
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12621
+        }
-12622
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case4
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case0_malformed_request() {
-12628
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/Infinity")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12646
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12661
+        }
-12662
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case5
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case1_malformed_request() {
-12668
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/-Infinity")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12686
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12701
+        }
-12702
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case6
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_path_integer_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case2_malformed_request() {
-12708
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/NaN")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12726
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12741
+        }
-12742
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case0
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case3_malformed_request() {
-12748
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=true".parse().unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12766
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12781
+        }
-12782
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case1
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case4_malformed_request() {
-12788
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=1.001".parse().unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12806
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12821
+        }
-12822
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case2
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case5_malformed_request() {
-12828
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=2ABC".parse().unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=-Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12846
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12861
+        }
-12862
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case3
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_long_malformed_value_rejected_case6_malformed_request() {
-12868
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=0x42".parse().unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12886
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12901
+        }
-12902
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case4
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case0_malformed_request() {
-12908
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("longInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12926
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12941
+        }
-12942
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case5
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case1_malformed_request() {
-12948
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("longInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=-Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-12966
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-12981
+        }
-12982
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case6
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_integer_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case2_malformed_request() {
-12988
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("longInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13006
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13021
+        }
-13022
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case0
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case3_malformed_request() {
-13028
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "true")
                 .header("longInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13046
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13061
+        }
-13062
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case1
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case4_malformed_request() {
-13068
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "1.001")
                 .header("longInHeader", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13086
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13101
+        }
-13102
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case2
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case5_malformed_request() {
-13108
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "2ABC")
                 .header("longInHeader", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13126
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13141
+        }
-13142
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case3
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_long_malformed_value_rejected_case6_malformed_request() {
-13148
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedLong/1")
                 .method("POST")
                 .header("integerInHeader", "0x42")
                 .header("longInHeader", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13166
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13181
+        }
-13182
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case4
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDSHORT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedShortInput`](crate::input::MalformedShortInput) using modelled bindings.
     pub struct MalformedShortInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedShortInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedShortInputFuture {
     type Output = Result<
         crate::input::MalformedShortInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedShortInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedShortInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDSHORT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_short::de_malformed_short_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedShortInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedShortOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_response(self)
-+
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedShortError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_short_test {
-+
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_underflow_overflow_case0_malformed_request() {
-13297
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("integerInHeader", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 40000 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13317
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13332
+        }
-13333
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case5
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_underflow_overflow_case1_malformed_request() {
-13339
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("integerInHeader", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : -40000 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13359
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13374
+        }
-13375
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case6
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_header_integer_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_underflow_overflow_case2_malformed_request() {
-13381
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("integerInHeader", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"shortInBody\" : -9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13403
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13418
+        }
-13419
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_list_test {
     /// When a dense list contains null, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonBodyMalformedListNullItem
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_body_malformed_list_null_item_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_underflow_overflow_case3_malformed_request() {
-13425
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedList")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"bodyList\" : [\"a\", null, \"b\", \"c\"] }".as_bytes(),
                         "{ \"shortInBody\" : 9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_list(move |input: crate::input::MalformedListInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedListOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13447
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13462
+        }
-13463
+    }
     /// When a list does not have a closing bracket, the response should be
     /// a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedListUnclosed
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_body_malformed_list_unclosed_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_underflow_overflow_case4_malformed_request() {
-13469
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedList")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"bodyList\" : [\"a\", \"b\", \"c\" }".as_bytes(),
                         "{ \"shortInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_list(move |input: crate::input::MalformedListInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedListOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13491
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13506
+        }
-13507
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_long_test {
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyLongUnderflowOverflow_case0
     /// Test ID: RestJsonPathShortUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_body_long_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_underflow_overflow_case0_malformed_request() {
-13513
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/40000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"longInBody\" : -184467440737095500000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13530
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13545
+        }
-13546
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyLongUnderflowOverflow_case1
     /// Test ID: RestJsonPathShortUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_body_long_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_underflow_overflow_case1_malformed_request() {
-13552
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/-40000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"longInBody\" : 184467440737095500000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13569
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13584
+        }
-13585
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyLongUnderflowOverflow_case2
     /// Test ID: RestJsonPathShortUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_body_long_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_underflow_overflow_case2_malformed_request() {
-13591
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/-9223372000000000000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"longInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13608
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13623
+        }
-13624
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathLongUnderflowOverflow_case0
     /// Test ID: RestJsonPathShortUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_path_long_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_underflow_overflow_case3_malformed_request() {
-13630
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/-184467440737095500000")
                 .uri("/MalformedShort/9223372000000000000")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13647
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13662
+        }
-13663
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathLongUnderflowOverflow_case1
     /// Test ID: RestJsonPathShortUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_path_long_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_underflow_overflow_case4_malformed_request() {
-13669
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/184467440737095500000")
                 .uri("/MalformedShort/123000000000000000000000")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13686
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13701
+        }
-13702
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathLongUnderflowOverflow_case2
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_path_long_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_underflow_overflow_case0_malformed_request() {
-13708
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/123000000000000000000000")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=40000".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13726
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13741
+        }
-13742
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryLongUnderflowOverflow_case0
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_query_long_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_underflow_overflow_case1_malformed_request() {
-13748
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=-184467440737095500000"
                 .parse()
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=-40000".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13766
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13781
+        }
-13782
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryLongUnderflowOverflow_case1
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_query_long_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_underflow_overflow_case2_malformed_request() {
-13788
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=184467440737095500000"
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=-9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13808
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13823
+        }
-13824
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryLongUnderflowOverflow_case2
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_query_long_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_underflow_overflow_case3_malformed_request() {
-13830
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=123000000000000000000000"
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13850
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13865
+        }
-13866
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderLongUnderflowOverflow_case0
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_header_long_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_underflow_overflow_case4_malformed_request() {
-13872
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "-184467440737095500000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=123000000000000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13892
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13907
+        }
-13908
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderLongUnderflowOverflow_case1
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_header_long_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_underflow_overflow_case0_malformed_request() {
-13914
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "184467440737095500000")
                 .header("shortInHeader", "40000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13932
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13947
+        }
-13948
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderLongUnderflowOverflow_case2
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_header_long_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_underflow_overflow_case1_malformed_request() {
-13954
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "123000000000000000000000")
                 .header("shortInHeader", "-40000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-13972
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-13987
+        }
-13988
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case0
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_underflow_overflow_case2_malformed_request() {
-13994
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"123\" }".as_bytes()),
                 ))
                 .header("shortInHeader", "-9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14012
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14027
+        }
-14028
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case1
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_underflow_overflow_case3_malformed_request() {
-14034
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : true }".as_bytes()),
                 ))
                 .header("shortInHeader", "9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14052
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14067
+        }
-14068
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case2
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_underflow_overflow_case4_malformed_request() {
-14074
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : 1.001 }".as_bytes()),
                 ))
                 .header("shortInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14092
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14107
+        }
-14108
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case3
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case0_malformed_request() {
-14114
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : 2ABC }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"123\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14134
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14149
+        }
-14150
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case4
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case1_malformed_request() {
-14156
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : 0x42 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14176
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14191
+        }
-14192
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case5
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case2_malformed_request() {
-14198
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : Infinity }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 1.001 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14218
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14233
+        }
-14234
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case6
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case3_malformed_request() {
-14240
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"Infinity\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 2ABC }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14260
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14275
+        }
-14276
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case7
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case4_malformed_request() {
-14282
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : -Infinity }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14302
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14317
+        }
-14318
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case8
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case5_malformed_request() {
-14324
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"-Infinity\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14344
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14359
+        }
-14360
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case9
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case6_malformed_request() {
-14366
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : NaN }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14386
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14401
+        }
-14402
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyLongMalformedValueRejected_case10
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case7
     #[::tokio::test]
     async fn rest_json_body_long_malformed_value_rejected_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case7_malformed_request() {
-14408
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"longInBody\" : \"NaN\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14428
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14443
+        }
-14444
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case8
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case8_malformed_request() {
-14450
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/true")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14470
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14485
+        }
-14486
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case9
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case9_malformed_request() {
-14492
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1.001")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14512
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14527
+        }
-14528
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case10
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_short_malformed_value_rejected_case10_malformed_request() {
-14534
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/2ABC")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14554
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14569
+        }
-14570
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case3
     /// Test ID: RestJsonPathShortMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case0_malformed_request() {
-14576
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/0x42")
                 .uri("/MalformedShort/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14593
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14608
+        }
-14609
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case4
     /// Test ID: RestJsonPathShortMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case1_malformed_request() {
-14615
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/Infinity")
                 .uri("/MalformedShort/1.001")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14632
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14647
+        }
-14648
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case5
     /// Test ID: RestJsonPathShortMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case2_malformed_request() {
-14654
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/-Infinity")
                 .uri("/MalformedShort/2ABC")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14671
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14686
+        }
-14687
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathLongMalformedValueRejected_case6
     /// Test ID: RestJsonPathShortMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_path_long_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case3_malformed_request() {
-14693
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/NaN")
                 .uri("/MalformedShort/0x42")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14710
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14725
+        }
-14726
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case0
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case4_malformed_request() {
-14732
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14749
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14764
+        }
-14765
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case1
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case5_malformed_request() {
-14771
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/-Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14788
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14803
+        }
-14804
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case2
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_short_malformed_value_rejected_case6_malformed_request() {
-14810
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/NaN")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14827
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14842
+        }
-14843
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case3
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case0_malformed_request() {
-14849
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=0x42".parse().unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14867
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14882
+        }
-14883
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case4
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case1_malformed_request() {
-14889
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=Infinity".parse().unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14907
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14922
+        }
-14923
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case5
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case2_malformed_request() {
-14929
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=-Infinity".parse().unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14947
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-14962
+        }
-14963
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryLongMalformedValueRejected_case6
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_query_long_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case3_malformed_request() {
-14969
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedLong/1?longInQuery=NaN".parse().unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-14987
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15002
+        }
-15003
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case0
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case4_malformed_request() {
-15009
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15027
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15042
+        }
-15043
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case1
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case5_malformed_request() {
-15049
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=-Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15067
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15082
+        }
-15083
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case2
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_short_malformed_value_rejected_case6_malformed_request() {
-15089
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15107
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15122
+        }
-15123
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case3
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case0_malformed_request() {
-15129
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "0x42")
                 .header("shortInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15147
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15162
+        }
-15163
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case4
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case1_malformed_request() {
-15169
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "Infinity")
                 .header("shortInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15187
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15202
+        }
-15203
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case5
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case2_malformed_request() {
-15209
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "-Infinity")
                 .header("shortInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15227
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15242
+        }
-15243
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderLongMalformedValueRejected_case6
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_header_long_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case3_malformed_request() {
-15249
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedLong/1")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("longInHeader", "NaN")
                 .header("shortInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_long(move |input: crate::input::MalformedLongInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedLongOutput, crate::error::MalformedLongError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15267
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15282
+        }
-15283
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_map_test {
     /// When a map contains a null key, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonBodyMalformedMapNullKey
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_body_malformed_map_null_key_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case4_malformed_request() {
-15289
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedMap")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"bodyMap\" : { null: \"abc\" }  }".as_bytes()),
                 ))
                 .header("shortInHeader", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_map(move |input: crate::input::MalformedMapInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedMapOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15307
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15322
+        }
-15323
+    }
     /// When a dense map contains a null value, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonBodyMalformedMapNullValue
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_body_malformed_map_null_value_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case5_malformed_request() {
-15329
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedMap")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"bodyMap\" : { \"abc\": null }  }".as_bytes()),
                 ))
                 .header("shortInHeader", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_map(move |input: crate::input::MalformedMapInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedMapOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15347
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15362
+        }
-15363
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_request_body_test {
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case0
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_short_malformed_value_rejected_case6_malformed_request() {
-15369
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedShort/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{[".as_bytes()),
                 ))
                 .header("shortInHeader", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15387
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15402
+        }
-15403
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case1
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDBYTE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedByteInput`](crate::input::MalformedByteInput) using modelled bindings.
     pub struct MalformedByteInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedByteInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedByteInputFuture {
     type Output = Result<
         crate::input::MalformedByteInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedByteInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedByteInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBYTE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_byte::de_malformed_byte_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedByteInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedByteOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedByteError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_byte_test {
-+
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_underflow_overflow_case0_malformed_request() {
-15517
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"int\": 10 }abc".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 256 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15537
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15552
+        }
-15553
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case2
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_underflow_overflow_case1_malformed_request() {
-15559
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("abc{ \"int\": 10 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : -256 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15579
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15594
+        }
-15595
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case3
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_underflow_overflow_case2_malformed_request() {
-15601
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{\n    \"int\": 10 // the integer should be 10\n}".as_bytes(),
                         "{ \"byteInBody\" : -9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15623
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15638
+        }
-15639
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case4
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_underflow_overflow_case3_malformed_request() {
-15645
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{\n    \"int\": 10 /* the integer should be 10 */\n}".as_bytes(),
                         "{ \"byteInBody\" : 9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15667
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15682
+        }
-15683
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case5
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyByteUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_underflow_overflow_case4_malformed_request() {
-15689
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{\"int\" :\\u{000c}10}".as_bytes()),
                     ::bytes::Bytes::from_static(
                         "{ \"byteInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15711
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15726
+        }
-15727
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case6
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_underflow_overflow_case0_malformed_request() {
-15733
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/256")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{'int': 10}".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15750
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15765
+        }
-15766
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case7
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_invalid_json_body_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_underflow_overflow_case1_malformed_request() {
-15772
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/-256")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{\"int\": 10,}".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15789
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15804
+        }
-15805
+    }
     /// When the request body is technically valid, but cannot map to a Smithy structure,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonTechnicallyValidJsonBody_case0
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_technically_valid_json_body_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_underflow_overflow_case2_malformed_request() {
-15811
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/-9223372000000000000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("[{ \"int\": 10}]".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15828
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15843
+        }
-15844
+    }
     /// When the request body is technically valid, but cannot map to a Smithy structure,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonTechnicallyValidJsonBody_case1
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_technically_valid_json_body_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_underflow_overflow_case3_malformed_request() {
-15850
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/9223372000000000000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("10".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15867
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15882
+        }
-15883
+    }
     /// When the request body is technically valid, but cannot map to a Smithy structure,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonTechnicallyValidJsonBody_case2
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathByteUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_technically_valid_json_body_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_underflow_overflow_case4_malformed_request() {
-15889
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .uri("/MalformedByte/123000000000000000000000")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("null".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15906
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15921
+        }
-15922
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_short_test {
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case0
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_body_short_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_underflow_overflow_case0_malformed_request() {
-15928
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 40000 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=256".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15946
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-15961
+        }
-15962
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case1
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_body_short_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_underflow_overflow_case1_malformed_request() {
-15968
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : -40000 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=-256".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-15986
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16001
+        }
-16002
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case2
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_body_short_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_underflow_overflow_case2_malformed_request() {
-16008
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"shortInBody\" : -9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=-9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16028
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16043
+        }
-16044
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case3
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_body_short_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_underflow_overflow_case3_malformed_request() {
-16050
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"shortInBody\" : 9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16070
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16085
+        }
-16086
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyShortUnderflowOverflow_case4
     /// Test ID: RestJsonQueryByteUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_body_short_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_underflow_overflow_case4_malformed_request() {
-16092
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"shortInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=123000000000000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16112
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16127
+        }
-16128
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathShortUnderflowOverflow_case0
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_path_short_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_underflow_overflow_case0_malformed_request() {
-16134
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/40000")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "256")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16152
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16167
+        }
-16168
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathShortUnderflowOverflow_case1
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_path_short_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_underflow_overflow_case1_malformed_request() {
-16174
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/-40000")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "-256")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16192
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16207
+        }
-16208
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathShortUnderflowOverflow_case2
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_path_short_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_underflow_overflow_case2_malformed_request() {
-16214
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/-9223372000000000000")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "-9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16232
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16247
+        }
-16248
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathShortUnderflowOverflow_case3
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case3
     #[::tokio::test]
     async fn rest_json_path_short_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_underflow_overflow_case3_malformed_request() {
-16254
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/9223372000000000000")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16272
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16287
+        }
-16288
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathShortUnderflowOverflow_case4
     /// Test ID: RestJsonHeaderByteUnderflowOverflow_case4
     #[::tokio::test]
     async fn rest_json_path_short_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_underflow_overflow_case4_malformed_request() {
-16294
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/123000000000000000000000")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16312
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16327
+        }
-16328
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_short_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case0_malformed_request() {
-16334
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"123\" }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=40000".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16354
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16369
+        }
-16370
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_short_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case1_malformed_request() {
-16376
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : true }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=-40000".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16396
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16411
+        }
-16412
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_short_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case2_malformed_request() {
-16418
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=-9223372000000000000"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 1.001 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16438
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16453
+        }
-16454
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case3
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_query_short_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case3_malformed_request() {
-16460
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=9223372000000000000"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 2ABC }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16480
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16495
+        }
-16496
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryShortUnderflowOverflow_case4
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_query_short_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case4_malformed_request() {
-16502
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=123000000000000000000000"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16522
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16537
+        }
-16538
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_header_short_underflow_overflow_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case5_malformed_request() {
-16544
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("shortInHeader", "40000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16564
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16579
+        }
-16580
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_header_short_underflow_overflow_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case6_malformed_request() {
-16586
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("shortInHeader", "-40000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16606
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16621
+        }
-16622
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case7
     #[::tokio::test]
     async fn rest_json_header_short_underflow_overflow_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case7_malformed_request() {
-16628
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("shortInHeader", "-9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16648
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16663
+        }
-16664
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case3
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case8
     #[::tokio::test]
     async fn rest_json_header_short_underflow_overflow_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case8_malformed_request() {
-16670
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("shortInHeader", "9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16690
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16705
+        }
-16706
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderShortUnderflowOverflow_case4
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case9
     #[::tokio::test]
     async fn rest_json_header_short_underflow_overflow_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case9_malformed_request() {
-16712
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("shortInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16732
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16747
+        }
-16748
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case0
     /// Test ID: RestJsonBodyByteMalformedValueRejected_case10
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_byte_malformed_value_rejected_case10_malformed_request() {
-16754
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"123\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"byteInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16774
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16789
+        }
-16790
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case1
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case0_malformed_request() {
-16796
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : true }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16813
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16828
+        }
-16829
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case2
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case1_malformed_request() {
-16835
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1.001")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 1.001 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16852
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16867
+        }
-16868
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case3
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case2_malformed_request() {
-16874
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/2ABC")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 2ABC }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16891
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16906
+        }
-16907
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case4
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case3_malformed_request() {
-16913
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/0x42")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : 0x42 }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16930
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16945
+        }
-16946
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case5
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case4_malformed_request() {
-16952
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/Infinity")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-16969
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-16984
+        }
-16985
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case6
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case5_malformed_request() {
-16991
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/-Infinity")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"Infinity\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17008
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17023
+        }
-17024
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case7
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathByteMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case7_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_byte_malformed_value_rejected_case6_malformed_request() {
-17030
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/NaN")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : -Infinity }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17047
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17062
+        }
-17063
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case8
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case8_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case0_malformed_request() {
-17069
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17087
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17102
+        }
-17103
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case9
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case9_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case1_malformed_request() {
-17109
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : NaN }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17127
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17142
+        }
-17143
+    }
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyShortMalformedValueRejected_case10
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_body_short_malformed_value_rejected_case10_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case2_malformed_request() {
-17149
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"shortInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17167
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17182
+        }
-17183
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case0
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case3_malformed_request() {
-17189
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/true")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17207
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17222
+        }
-17223
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case1
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case4_malformed_request() {
-17229
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1.001")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17247
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17262
+        }
-17263
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case2
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case5_malformed_request() {
-17269
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/2ABC")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=-Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17287
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17302
+        }
-17303
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case3
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryByteMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_byte_malformed_value_rejected_case6_malformed_request() {
-17309
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/0x42")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedByte/1?byteInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17327
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17342
+        }
-17343
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case4
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case0_malformed_request() {
-17349
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/Infinity")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17367
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17382
+        }
-17383
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case5
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case1_malformed_request() {
-17389
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/-Infinity")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17407
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17422
+        }
-17423
+    }
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathShortMalformedValueRejected_case6
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_path_short_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case2_malformed_request() {
-17429
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/NaN")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17447
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17462
+        }
-17463
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case0
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case3_malformed_request() {
-17469
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17487
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17502
+        }
-17503
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case1
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case4_malformed_request() {
-17509
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17527
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17542
+        }
-17543
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case2
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case5_malformed_request() {
-17549
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17567
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17582
+        }
-17583
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case3
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderByteMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_byte_malformed_value_rejected_case6_malformed_request() {
-17589
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedByte/1")
                 .method("POST")
                 .header("byteInHeader", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_byte(move |input: crate::input::MalformedByteInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedByteOutput, crate::error::MalformedByteError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17607
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17622
+        }
-17623
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case4
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDBLOB: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedBlobInput`](crate::input::MalformedBlobInput) using modelled bindings.
     pub struct MalformedBlobInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBlobInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedBlobInputFuture {
     type Output = Result<
         crate::input::MalformedBlobInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBlobInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBLOB,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_blob::de_malformed_blob_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedBlobInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBlobOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_blob::ser_malformed_blob_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_blob_test {
-+
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case0
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case0_malformed_request() {
-17718
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : blob }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17738
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17753
+        }
-17754
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case5
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case1
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case1_malformed_request() {
-17761
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : \"xyz\" }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=-Infinity".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17781
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17796
+        }
-17797
+    }
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryShortMalformedValueRejected_case6
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case2
     #[::tokio::test]
     async fn rest_json_query_short_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case2_malformed_request() {
-17804
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : \"YmxvYg=\" }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedShort/1?shortInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17824
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17839
+        }
-17840
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case0
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case3
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case3_malformed_request() {
-17847
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("shortInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : [98, 108, 11, 98] }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17867
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17882
+        }
-17883
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case1
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case4
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case4_malformed_request() {
-17890
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("shortInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"blob\" : [\"b\", \"l\",\"o\",\"b\"] }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17912
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17927
+        }
-17928
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case2
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case5
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case5_malformed_request() {
-17935
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("shortInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : 981081198 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17955
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-17970
+        }
-17971
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case3
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case6
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case6_malformed_request() {
-17978
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("shortInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : true }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-17998
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18013
+        }
-18014
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case4
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case7
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case7_malformed_request() {
-18021
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("shortInHeader", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : [][] }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18041
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18056
+        }
-18057
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case5
     /// When a blob member is not properly base64 encoded, or not encoded at
     /// all, the response should be a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedBlobInvalidBase64_case8
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_blob_invalid_base64_case8_malformed_request() {
-18064
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedBlob")
                 .method("POST")
                 .header("shortInHeader", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"blob\" : -_== }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_blob(move |input: crate::input::MalformedBlobInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedBlobOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18084
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18099
+        }
-18100
+    }
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderShortMalformedValueRejected_case6
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDMAP: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedMapInput`](crate::input::MalformedMapInput) using modelled bindings.
     pub struct MalformedMapInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedMapInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedMapInputFuture {
     type Output = Result<
         crate::input::MalformedMapInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedMapInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedMapInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDMAP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_map::de_malformed_map_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedMapInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedMapOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_map::ser_malformed_map_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_map_test {
-+
     /// When a map contains a null key, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonBodyMalformedMapNullKey
     #[::tokio::test]
     async fn rest_json_header_short_malformed_value_rejected_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_map_null_key_malformed_request() {
-18195
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedShort/1")
                 .uri("/MalformedMap")
                 .method("POST")
                 .header("shortInHeader", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"bodyMap\" : { null: \"abc\" }  }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_short(move |input: crate::input::MalformedShortInput| {
                             .malformed_map(move |input: crate::input::MalformedMapInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedShortOutput, crate::error::MalformedShortError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedMapOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18215
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18230
+        }
-18231
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_string_test {
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case0
     /// When a dense map contains a null value, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonBodyMalformedMapNullValue
     #[::tokio::test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_map_null_value_malformed_request() {
-18238
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedString")
                 .uri("/MalformedMap")
                 .method("POST")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "xyz")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"bodyMap\" : { \"abc\": null }  }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                             .malformed_map(move |input: crate::input::MalformedMapInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedMapOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18258
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18273
+        }
-18274
+    }
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case1
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDLIST: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedListInput`](crate::input::MalformedListInput) using modelled bindings.
     pub struct MalformedListInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedListInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedListInputFuture {
     type Output = Result<
         crate::input::MalformedListInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedListInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedListInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLIST,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_list::de_malformed_list_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedListInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedListOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_list::ser_malformed_list_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_list_test {
-+
     /// When a dense list contains null, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonBodyMalformedListNullItem
     #[::tokio::test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_list_null_item_malformed_request() {
-18369
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedString")
                 .uri("/MalformedList")
                 .method("POST")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "YmxvYg=")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"bodyList\" : [\"a\", null, \"b\", \"c\"] }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                             .malformed_list(move |input: crate::input::MalformedListInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedListOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18391
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18406
+        }
-18407
+    }
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case2
     /// When a list does not have a closing bracket, the response should be
     /// a 400 SerializationException.
     /// Test ID: RestJsonBodyMalformedListUnclosed
     #[::tokio::test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_malformed_list_unclosed_malformed_request() {
-18414
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedString")
                 .uri("/MalformedList")
                 .method("POST")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "[][]")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"bodyList\" : [\"a\", \"b\", \"c\" }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                             .malformed_list(move |input: crate::input::MalformedListInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedListOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18436
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18451
+        }
-18452
+    }
     /// When string with the mediaType trait is bound to a header, its value
     /// must be base64 encoded. The server should reject values that aren't
     /// valid base64 out of hand.
     /// Test ID: RestJsonHeaderMalformedStringInvalidBase64MediaType_case3
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDBOOLEAN: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedBooleanInput`](crate::input::MalformedBooleanInput) using modelled bindings.
     pub struct MalformedBooleanInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBooleanInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedBooleanInputFuture {
     type Output = Result<
         crate::input::MalformedBooleanInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBooleanInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBooleanInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBOOLEAN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_boolean::de_malformed_boolean_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedBooleanInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBooleanOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedBooleanError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_boolean_test {
-+
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case0
     #[::tokio::test]
     async fn rest_json_header_malformed_string_invalid_base64_media_type_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case0_malformed_request() {
-18572
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedString")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .header("amz-media-typed-header", "-_==")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"true\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_string(move |input: crate::input::MalformedStringInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedStringOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18592
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18607
+        }
-18608
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_body_date_time_test {
     /// When the format is date-time, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsHttpDate_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case1
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case1_malformed_request() {
-18614
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"Tue, 29 Apr 2014 18:30:38 GMT\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"True\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18634
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18649
+        }
-18650
+    }
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsEpochSeconds_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case2
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case2_malformed_request() {
-18656
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081.1234 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"TRUE\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18676
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18691
+        }
-18692
+    }
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsEpochSeconds_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case3
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case3_malformed_request() {
-18698
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"y\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18718
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18733
+        }
-18734
+    }
     /// When the format is date-time, RFC 3339 timestamps with a UTC offset are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsUTCOffsets_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case4
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_utc_offsets_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case4_malformed_request() {
-18740
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57-08:00\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"Y\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18760
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18775
+        }
-18776
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case5
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case0_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case5_malformed_request() {
-18782
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57+00\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"yes\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18802
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18817
+        }
-18818
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case6
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case1_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case6_malformed_request() {
-18824
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57+00Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"Yes\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18844
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18859
+        }
--
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case2
-+
+    }
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case7
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case2_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case7_malformed_request() {
-18866
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"YES\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18886
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18901
+        }
-18902
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case3
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case8
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case3_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case8_malformed_request() {
-18908
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T163957\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"1\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18928
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18943
+        }
-18944
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case4
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case9
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case4_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case9_malformed_request() {
-18950
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T163957Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"on\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-18970
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-18985
+        }
-18986
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case5
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case10
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case5_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case10_malformed_request() {
-18992
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T163957\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"On\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19012
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19027
+        }
-19028
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case6
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case11
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case6_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case11_malformed_request() {
-19034
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T16:39:57Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"ON\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19054
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19069
+        }
-19070
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case7
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case12
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case7_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case12_malformed_request() {
-19076
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"19961219T16:39:57\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"false\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19096
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19111
+        }
-19112
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case8
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case13
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case8_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case13_malformed_request() {
-19118
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"False\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19138
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19153
+        }
-19154
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case9
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case14
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case9_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case14_malformed_request() {
-19160
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"FALSE\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19180
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19195
+        }
-19196
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case10
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case15
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case10_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case15_malformed_request() {
-19202
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T1639\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"n\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19222
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19237
+        }
-19238
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case11
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case16
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case11_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case16_malformed_request() {
-19244
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"1996-12-19T16Z\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"N\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19264
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19279
+        }
-19280
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case12
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case17
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case12_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case17_malformed_request() {
-19286
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"1996-12-19T16\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"no\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19306
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19321
+        }
-19322
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case13
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case18
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case13_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case18_malformed_request() {
-19328
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19 16:39:57Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"No\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19348
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19363
+        }
-19364
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDateTimeRejectsDifferent8601Formats_case14
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case19
     #[::tokio::test]
     async fn rest_json_body_timestamp_date_time_rejects_different8601_formats_case14_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case19_malformed_request() {
-19370
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"2011-12-03T10:15:30+01:00[Europe/Paris]\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"NO\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_date_time(move |input: crate::input::MalformedTimestampBodyDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDateTimeOutput, crate::error::MalformedTimestampBodyDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19390
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19405
+        }
-19406
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_body_default_test {
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsDateTime_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case20
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case20_malformed_request() {
-19412
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50.52Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"0\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19432
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19447
+        }
-19448
+    }
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsDateTime_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case21
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case21_malformed_request() {
-19454
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"off\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19474
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19489
+        }
-19490
+    }
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsDateTime_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case22
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case22_malformed_request() {
-19496
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57-08:00\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"Off\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19516
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19531
+        }
-19532
+    }
     /// By default, epoch second timestamps as strings are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsStringifiedEpochSeconds_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonBodyBooleanStringCoercion_case23
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_stringified_epoch_seconds_case0_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_string_coercion_case23_malformed_request() {
-19538
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1515531081.1234\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : \"OFF\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19558
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19573
+        }
-19574
+    }
     /// By default, epoch second timestamps as strings are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsStringifiedEpochSeconds_case1
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case0
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_stringified_epoch_seconds_case1_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case0_malformed_request() {
-19580
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"1515531081\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : True }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19600
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19615
+        }
-19616
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case1
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case0_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case1_malformed_request() {
-19622
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": true }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : TRUE }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19642
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19657
+        }
-19658
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case1
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case2
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case1_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case2_malformed_request() {
-19664
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081ABC }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : y }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19684
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19699
+        }
-19700
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case2
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case3
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case2_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case3_malformed_request() {
-19706
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 0x42 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : Y }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19726
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19741
+        }
-19742
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case3
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case4
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case3_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case4_malformed_request() {
-19748
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081.123.456 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : yes }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19768
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19783
+        }
-19784
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case4
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case5
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case4_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case5_malformed_request() {
-19790
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": Infinity }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : Yes }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19810
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19825
+        }
-19826
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case5
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case6
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case5_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case6_malformed_request() {
-19832
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"Infinity\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : YES }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19852
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19867
+        }
-19868
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case6
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case7
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case6_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case7_malformed_request() {
-19874
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": -Infinity }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : 1 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19894
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19909
+        }
-19910
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case7
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case8
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case7_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case8_malformed_request() {
-19916
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"-Infinity\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : on }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19936
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19951
+        }
-19952
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case8
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case9
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case8_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case9_malformed_request() {
-19958
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": NaN }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : On }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-19978
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-19993
+        }
-19994
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsMalformedEpochSeconds_case9
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case10
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_malformed_epoch_seconds_case9_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case10_malformed_request() {
-20000
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": \"NaN\" }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : ON }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20020
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20035
+        }
-20036
+    }
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampDefaultRejectsHttpDate_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case11
     #[::tokio::test]
     async fn rest_json_body_timestamp_default_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case11_malformed_request() {
-20042
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyDefault")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"Tue, 29 Apr 2014 18:30:38 GMT\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : False }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_default(move |input: crate::input::MalformedTimestampBodyDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyDefaultOutput, crate::error::MalformedTimestampBodyDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20062
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20077
+        }
-20078
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_body_http_date_test {
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsDateTime_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case12
     #[::tokio::test]
     async fn rest_json_body_timestamp_http_date_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case12_malformed_request() {
-20084
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50.52Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : FALSE }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20104
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20119
+        }
-20120
+    }
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsDateTime_case1
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case13
     #[::tokio::test]
     async fn rest_json_body_timestamp_http_date_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case13_malformed_request() {
-20126
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1985-04-12T23:20:50Z\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : n }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20146
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20161
+        }
-20162
+    }
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsDateTime_case2
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case14
     #[::tokio::test]
     async fn rest_json_body_timestamp_http_date_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case14_malformed_request() {
-20168
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"timestamp\": \"1996-12-19T16:39:57-08:00\" }".as_bytes(),
                     ),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : N }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20188
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20203
+        }
-20204
+    }
     /// When the format is http-date, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsEpoch_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case15
     #[::tokio::test]
     async fn rest_json_body_timestamp_http_date_rejects_epoch_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case15_malformed_request() {
-20210
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081.1234 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : no }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20230
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20245
+        }
-20246
+    }
     /// When the format is http-date, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonBodyTimestampHttpDateRejectsEpoch_case1
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case16
     #[::tokio::test]
     async fn rest_json_body_timestamp_http_date_rejects_epoch_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case16_malformed_request() {
-20252
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampBodyHttpDate")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"timestamp\": 1515531081 }".as_bytes()),
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : No }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_body_http_date(move |input: crate::input::MalformedTimestampBodyHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampBodyHttpDateOutput, crate::error::MalformedTimestampBodyHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20272
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20287
+        }
-20288
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_header_date_time_test {
     /// When the format is date-time, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsHttpDate_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case17
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case17_malformed_request() {
-20294
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "Tue, 29 Apr 2014 18:30:38 GMT")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : NO }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20314
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20329
+        }
-20330
+    }
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsEpochSeconds_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case18
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case18_malformed_request() {
-20336
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "1515531081.1234")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : 0 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20356
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20371
+        }
-20372
+    }
     /// When the format is date-time, epoch-seconds timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsEpochSeconds_case1
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case19
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case19_malformed_request() {
-20378
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "1515531081")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : off }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20398
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20413
+        }
-20414
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case0
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case20
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case0_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case20_malformed_request() {
-20420
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57+00")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : Off }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20440
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20455
+        }
-20456
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case1
     /// YAML-style alternate boolean literals should result in SerializationException
     /// Test ID: RestJsonBodyBooleanBadLiteral_case21
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case1_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_boolean_bad_literal_case21_malformed_request() {
-20462
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57+00Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"booleanInBody\" : OFF }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20482
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20497
+        }
-20498
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case0
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case2_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case0_malformed_request() {
-20504
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/True")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20521
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20536
+        }
-20537
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case3
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case1
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case3_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case1_malformed_request() {
-20543
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/TRUE")
                 .method("POST")
                 .header("timestamp", "1996-12-19T163957")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20560
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20575
+        }
-20576
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case4
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case2
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case4_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case2_malformed_request() {
-20582
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/y")
                 .method("POST")
                 .header("timestamp", "19961219T163957Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20599
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20614
+        }
-20615
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case5
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case3
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case5_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case3_malformed_request() {
-20621
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/Y")
                 .method("POST")
                 .header("timestamp", "19961219T163957")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20638
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20653
+        }
-20654
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case6
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case4
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case6_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case4_malformed_request() {
-20660
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/yes")
                 .method("POST")
                 .header("timestamp", "19961219T16:39:57Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20677
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20692
+        }
-20693
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case7
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case5
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case7_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case5_malformed_request() {
-20699
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/Yes")
                 .method("POST")
                 .header("timestamp", "19961219T16:39:57")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20716
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20731
+        }
-20732
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case8
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case6
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case8_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case6_malformed_request() {
-20738
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/YES")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20755
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20770
+        }
-20771
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case9
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case7
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case9_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case7_malformed_request() {
-20777
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/1")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20794
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20809
+        }
-20810
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case10
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case8
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case10_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case8_malformed_request() {
-20816
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/on")
                 .method("POST")
                 .header("timestamp", "1996-12-19T1639")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20833
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20848
+        }
-20849
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case11
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case9
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case11_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case9_malformed_request() {
-20855
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/On")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20872
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20887
+        }
-20888
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case12
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case10
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case12_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case10_malformed_request() {
-20894
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/ON")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20911
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20926
+        }
-20927
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case13
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case11
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case13_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case11_malformed_request() {
-20933
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/False")
                 .method("POST")
                 .header("timestamp", "1996-12-19 16:39:57Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20950
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-20965
+        }
-20966
+    }
     /// When the format is date-time, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDateTimeRejectsDifferent8601Formats_case14
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case12
     #[::tokio::test]
     async fn rest_json_header_timestamp_date_time_rejects_different8601_formats_case14_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case12_malformed_request() {
-20972
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDateTime")
                 .uri("/MalformedBoolean/FALSE")
                 .method("POST")
                 .header("timestamp", "2011-12-03T10:15:30+01:00[Europe/Paris]")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_date_time(move |input: crate::input::MalformedTimestampHeaderDateTimeInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDateTimeOutput, crate::error::MalformedTimestampHeaderDateTimeError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-20989
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21004
+        }
-21005
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_header_default_test {
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsDateTime_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case13
     #[::tokio::test]
     async fn rest_json_header_timestamp_default_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case13_malformed_request() {
-21011
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDefault")
                 .uri("/MalformedBoolean/n")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50.52Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21028
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21043
+        }
-21044
+    }
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsDateTime_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case14
     #[::tokio::test]
     async fn rest_json_header_timestamp_default_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case14_malformed_request() {
-21050
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDefault")
                 .uri("/MalformedBoolean/N")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21067
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21082
+        }
-21083
+    }
     /// By default, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsDateTime_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case15
     #[::tokio::test]
     async fn rest_json_header_timestamp_default_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case15_malformed_request() {
-21089
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDefault")
                 .uri("/MalformedBoolean/no")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57-08:00")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21106
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21121
+        }
-21122
+    }
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsEpochSeconds_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case16
     #[::tokio::test]
     async fn rest_json_header_timestamp_default_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case16_malformed_request() {
-21128
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDefault")
                 .uri("/MalformedBoolean/No")
                 .method("POST")
                 .header("timestamp", "1515531081.1234")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21145
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21160
+        }
-21161
+    }
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampDefaultRejectsEpochSeconds_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case17
     #[::tokio::test]
     async fn rest_json_header_timestamp_default_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case17_malformed_request() {
-21167
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderDefault")
                 .uri("/MalformedBoolean/NO")
                 .method("POST")
                 .header("timestamp", "1515531081")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_default(move |input: crate::input::MalformedTimestampHeaderDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderDefaultOutput, crate::error::MalformedTimestampHeaderDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21184
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21199
+        }
-21200
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_header_epoch_test {
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsDateTime_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case18
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case18_malformed_request() {
-21206
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/0")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50.52Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21223
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21238
+        }
-21239
+    }
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsDateTime_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case19
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case19_malformed_request() {
-21245
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/off")
                 .method("POST")
                 .header("timestamp", "1985-04-12T23:20:50Z")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21262
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21277
+        }
-21278
+    }
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsDateTime_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case20
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case20_malformed_request() {
-21284
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/Off")
                 .method("POST")
                 .header("timestamp", "1996-12-19T16:39:57-08:00")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21301
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21316
+        }
-21317
+    }
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsHttpDate_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonPathBooleanStringCoercion_case21
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_boolean_string_coercion_case21_malformed_request() {
-21323
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/OFF")
                 .method("POST")
                 .header("timestamp", "Tue, 29 Apr 2014 18:30:38 GMT")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21340
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21355
+        }
-21356
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case0
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case0_malformed_request() {
-21362
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=True"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21382
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21397
+        }
-21398
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case1
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case1_malformed_request() {
-21404
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "1515531081ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=TRUE"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21424
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21439
+        }
-21440
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case2
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case2_malformed_request() {
-21446
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=y".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21464
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21479
+        }
-21480
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case3
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case3
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case3_malformed_request() {
-21486
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "1515531081.123.456")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=Y".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21504
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21519
+        }
-21520
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case4
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case4
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case4_malformed_request() {
-21526
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=yes".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21544
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21559
+        }
-21560
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case5
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case5
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case5_malformed_request() {
-21566
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=Yes".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21584
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21599
+        }
-21600
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonHeaderTimestampEpochRejectsMalformedValues_case6
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case6
     #[::tokio::test]
     async fn rest_json_header_timestamp_epoch_rejects_malformed_values_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case6_malformed_request() {
-21606
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampHeaderEpoch")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("timestamp", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=YES".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_header_epoch(move |input: crate::input::MalformedTimestampHeaderEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampHeaderEpochOutput, crate::error::MalformedTimestampHeaderEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21624
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21639
+        }
-21640
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_path_default_test {
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsHttpDate_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case7
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case7_malformed_request() {
-21646
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=1".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21664
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21679
+        }
-21680
+    }
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsHttpDate_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case8
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_http_date_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case8_malformed_request() {
-21686
+        {
             #[allow(unused_mut)]
                         let mut http_request = http::Request::builder()
                             .uri("/MalformedTimestampPathDefault/Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT")
                             .method("POST")
             .body(::aws_smithy_http_server::body::Body::empty()).unwrap();
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=on".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21704
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21719
+        }
-21720
+    }
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsEpochSeconds_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case9
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case9_malformed_request() {
-21726
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1515531081.1234")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=On".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21744
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21759
+        }
-21760
+    }
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsEpochSeconds_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case10
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case10_malformed_request() {
-21766
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1515531081")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=ON".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21784
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21799
+        }
-21800
+    }
     /// UTC offsets must be rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsUTCOffsets
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case11
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_utc_offsets_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case11_malformed_request() {
-21806
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57-08%3A00")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=False"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21826
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21841
+        }
-21842
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case12
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case0_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case12_malformed_request() {
-21848
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57%2B00")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=FALSE"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21868
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21883
+        }
-21884
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case13
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case1_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case13_malformed_request() {
-21890
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57%2B00Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=n".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21908
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21923
+        }
-21924
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case14
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case2_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case14_malformed_request() {
-21930
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39%3A57")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=N".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21948
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-21963
+        }
-21964
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case3
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case15
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case3_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case15_malformed_request() {
-21970
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T163957")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=no".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-21988
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22003
+        }
-22004
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case4
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case16
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case4_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case16_malformed_request() {
-22010
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/19961219T163957Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=No".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22028
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22043
+        }
-22044
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case5
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case17
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case5_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case17_malformed_request() {
-22050
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/19961219T163957")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=NO".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22068
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22083
+        }
-22084
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case6
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case18
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case6_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case18_malformed_request() {
-22090
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/19961219T16%3A39%3A57Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=0".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22108
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22123
+        }
-22124
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case7
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case19
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case7_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case19_malformed_request() {
-22130
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/19961219T16%3A39%3A57")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=off".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22148
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22163
+        }
-22164
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case8
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case20
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case8_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case20_malformed_request() {
-22170
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=Off".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22188
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22203
+        }
-22204
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case9
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonQueryBooleanStringCoercion_case21
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case9_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_boolean_string_coercion_case21_malformed_request() {
-22210
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16%3A39")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedBoolean/true?booleanInQuery=OFF".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22228
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22243
+        }
-22244
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case10
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case0
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case10_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case0_malformed_request() {
-22250
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T1639")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "True")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22268
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22283
+        }
-22284
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case11
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case1
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case11_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case1_malformed_request() {
-22290
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "TRUE")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22308
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22323
+        }
-22324
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case12
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case2
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case12_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case2_malformed_request() {
-22330
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19T16")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "y")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22348
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22363
+        }
-22364
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case13
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case3
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case13_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case3_malformed_request() {
-22370
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathDefault/1996-12-19%2016%3A39%3A57Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "Y")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22388
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22403
+        }
-22404
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampDefaultRejectsDifferent8601Formats_case14
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case4
     #[::tokio::test]
     async fn rest_json_path_timestamp_default_rejects_different8601_formats_case14_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case4_malformed_request() {
-22410
+        {
             #[allow(unused_mut)]
                         let mut http_request = http::Request::builder()
                             .uri("/MalformedTimestampPathDefault/2011-12-03T10%3A15%3A30%2B01%3A00%5BEurope%2FParis%5D")
                             .method("POST")
             .body(::aws_smithy_http_server::body::Body::empty()).unwrap();
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "yes")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_default(move |input: crate::input::MalformedTimestampPathDefaultInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathDefaultOutput, crate::error::MalformedTimestampPathDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22428
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22443
+        }
-22444
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_path_epoch_test {
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsDateTime_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case5
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case5_malformed_request() {
-22450
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/1985-04-12T23%3A20%3A50.52Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "Yes")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22468
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22483
+        }
-22484
+    }
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsDateTime_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case6
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case6_malformed_request() {
-22490
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/1985-04-12T23%3A20%3A50Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "YES")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22508
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22523
+        }
-22524
+    }
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsDateTime_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case7
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case7_malformed_request() {
-22530
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/1996-12-19T16%3A39%3A57-08%3A00")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "1")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22548
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22563
+        }
-22564
+    }
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsHttpDate_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case8
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case8_malformed_request() {
-22570
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "on")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22588
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22603
+        }
-22604
+    }
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsHttpDate_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case9
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_http_date_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case9_malformed_request() {
-22610
+        {
             #[allow(unused_mut)]
                         let mut http_request = http::Request::builder()
                             .uri("/MalformedTimestampPathEpoch/Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT")
                             .method("POST")
             .body(::aws_smithy_http_server::body::Body::empty()).unwrap();
             let mut http_request = http::Request::builder()
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "On")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22628
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22643
+        }
-22644
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case10
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case10_malformed_request() {
-22650
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/true")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "ON")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22668
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22683
+        }
-22684
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case11
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case11_malformed_request() {
-22690
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/1515531081ABC")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "False")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22708
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22723
+        }
-22724
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case12
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case12_malformed_request() {
-22730
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/0x42")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "FALSE")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22748
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22763
+        }
-22764
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case3
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case13
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case13_malformed_request() {
-22770
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/1515531081.123.456")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "n")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22788
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22803
+        }
-22804
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case4
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case14
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case14_malformed_request() {
-22810
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/Infinity")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "N")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22828
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22843
+        }
-22844
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case5
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case15
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case15_malformed_request() {
-22850
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/-Infinity")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "no")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22868
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22883
+        }
-22884
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonPathTimestampEpochRejectsMalformedValues_case6
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case16
     #[::tokio::test]
     async fn rest_json_path_timestamp_epoch_rejects_malformed_values_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case16_malformed_request() {
-22890
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathEpoch/NaN")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "No")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_epoch(move |input: crate::input::MalformedTimestampPathEpochInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathEpochOutput, crate::error::MalformedTimestampPathEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22908
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22923
+        }
-22924
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_path_http_date_test {
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsDateTime_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case17
     #[::tokio::test]
     async fn rest_json_path_timestamp_http_date_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case17_malformed_request() {
-22930
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathHttpDate/1985-04-12T23%3A20%3A50.52Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "NO")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22948
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-22963
+        }
-22964
+    }
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsDateTime_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case18
     #[::tokio::test]
     async fn rest_json_path_timestamp_http_date_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case18_malformed_request() {
-22970
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathHttpDate/1985-04-12T23%3A20%3A50Z")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "0")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-22988
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23003
+        }
-23004
+    }
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsDateTime_case2
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case19
     #[::tokio::test]
     async fn rest_json_path_timestamp_http_date_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case19_malformed_request() {
-23010
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathHttpDate/1996-12-19T16%3A39%3A57-08%3A00")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "off")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23028
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23043
+        }
-23044
+    }
     /// When the format is http-date,  epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsEpochSeconds_case0
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case20
     #[::tokio::test]
     async fn rest_json_path_timestamp_http_date_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case20_malformed_request() {
-23050
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathHttpDate/1515531081.1234")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "Off")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23068
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23083
+        }
-23084
+    }
     /// When the format is http-date,  epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonPathTimestampHttpDateRejectsEpochSeconds_case1
     /// Attempted string coercion should result in SerializationException
     /// Test ID: RestJsonHeaderBooleanStringCoercion_case21
     #[::tokio::test]
     async fn rest_json_path_timestamp_http_date_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_header_boolean_string_coercion_case21_malformed_request() {
-23090
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampPathHttpDate/1515531081")
                 .uri("/MalformedBoolean/true")
                 .method("POST")
                 .header("booleanInHeader", "OFF")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_path_http_date(move |input: crate::input::MalformedTimestampPathHttpDateInput| {
                             .malformed_boolean(move |input: crate::input::MalformedBooleanInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampPathHttpDateOutput, crate::error::MalformedTimestampPathHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedBooleanOutput, crate::error::MalformedBooleanError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23108
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23123
+        }
-23124
+    }
-23125
+}
 #[cfg(test)]
-+
 const CONTENT_TYPE_MALFORMEDUNION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedUnionInput`](crate::input::MalformedUnionInput) using modelled bindings.
     pub struct MalformedUnionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedUnionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedUnionInputFuture {
     type Output = Result<
         crate::input::MalformedUnionInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUnionInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDUNION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_union::de_malformed_union_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedUnionInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUnionOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_union::ser_malformed_union_http_response(self)
-+
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_query_default_test {
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsHttpDate_case0
 #[cfg(test)]
 mod malformed_union_test {
-+
     /// When the union has multiple fields set, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionMultipleFieldsSet
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_union_multiple_fields_set_malformed_request() {
-23220
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedUnion")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"union\" : { \"int\": 2, \"string\": \"three\" } }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23242
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23257
+        }
-23258
+    }
     /// By default, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsHttpDate_case1
     /// When the union has multiple fields set, even when only one is modeled,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonMalformedUnionKnownAndUnknownFieldsSet
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_http_date_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_union_known_and_unknown_fields_set_malformed_request() {
-23265
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedUnion")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"union\" : { \"int\": 2, \"unknownField\": \"three\" } }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23287
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23302
+        }
-23303
+    }
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsEpochSeconds_case0
     /// When the union has no fields set, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionNoFieldsSet
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_union_no_fields_set_malformed_request() {
-23310
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedUnion")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1515531081.1234"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"union\" : { \"int\": null } }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23330
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23345
+        }
-23346
+    }
     /// By default, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsEpochSeconds_case1
     /// When the union value is actually an array, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionValueIsArray
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_union_value_is_array_malformed_request() {
-23353
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedUnion")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1515531081"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"union\" : [\"int\"] }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23373
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23388
+        }
-23389
+    }
     /// UTC offsets must be rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsUTCOffsets
     /// When an unknown union member is received, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionUnknownMember
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_utc_offsets_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_malformed_union_unknown_member_malformed_request() {
-23396
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedUnion")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=$value:L"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{\n    \"union\": {\n        \"unknown\": \"hello\"\n    }\n}".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23418
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23433
+        }
-23434
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case0
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDINTEGER: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedIntegerInput`](crate::input::MalformedIntegerInput) using modelled bindings.
     pub struct MalformedIntegerInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedIntegerInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for MalformedIntegerInputFuture {
     type Output = Result<
         crate::input::MalformedIntegerInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedIntegerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedIntegerInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDINTEGER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_integer::de_malformed_integer_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         MalformedIntegerInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedIntegerOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedIntegerError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod malformed_integer_test {
-+
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyIntegerUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case0_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_underflow_overflow_case0_malformed_request() {
-23554
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"integerInBody\" : -9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39:57+00"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23576
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23591
+        }
-23592
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case1
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyIntegerUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case1_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_underflow_overflow_case1_malformed_request() {
-23598
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"integerInBody\" : 9223372000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39:57+00Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23620
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23635
+        }
-23636
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case2
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonBodyIntegerUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case2_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_underflow_overflow_case2_malformed_request() {
-23642
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"integerInBody\" : 123000000000000000000000 }".as_bytes(),
                     ),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39:57"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23664
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
--
+        }
--
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case3
-+
+        }
-+
+    }
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathIntegerUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case3_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_underflow_overflow_case0_malformed_request() {
-23686
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/-9223372000000000000")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T163957"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23703
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23718
+        }
-23719
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case4
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathIntegerUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case4_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_underflow_overflow_case1_malformed_request() {
-23725
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/9223372000000000000")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=19961219T163957Z"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23742
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23757
+        }
-23758
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case5
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonPathIntegerUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case5_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_underflow_overflow_case2_malformed_request() {
-23764
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/123000000000000000000000")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=19961219T163957"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23781
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23796
+        }
-23797
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case6
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryIntegerUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case6_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_underflow_overflow_case0_malformed_request() {
-23803
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=19961219T16:39:57Z"
                     .parse()
                     .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=-9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23823
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23838
+        }
-23839
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case7
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryIntegerUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case7_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_underflow_overflow_case1_malformed_request() {
-23845
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=19961219T16:39:57"
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=9223372000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23865
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23880
+        }
-23881
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case8
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonQueryIntegerUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case8_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_underflow_overflow_case2_malformed_request() {
-23887
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39Z"
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=123000000000000000000000"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23907
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23922
+        }
-23923
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case9
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderIntegerUnderflowOverflow_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case9_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_underflow_overflow_case0_malformed_request() {
-23929
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "-9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16:39"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23947
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-23962
+        }
-23963
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case10
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderIntegerUnderflowOverflow_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case10_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_underflow_overflow_case1_malformed_request() {
-23969
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "9223372000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T1639"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-23987
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24002
+        }
-24003
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case11
     /// Underflow or overflow should result in SerializationException
     /// Test ID: RestJsonHeaderIntegerUnderflowOverflow_case2
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case11_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_underflow_overflow_case2_malformed_request() {
-24009
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "123000000000000000000000")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16Z"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24027
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24042
+        }
-24043
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case12
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case12_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case0_malformed_request() {
-24049
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryDefault?timestamp=1996-12-19T16"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"123\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24069
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24084
+        }
-24085
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case13
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case13_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case1_malformed_request() {
-24091
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : true }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=1996-12-19%2016:39:57Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24111
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24126
+        }
-24127
+    }
     /// By default, maybe-valid ISO-8601 date-times not conforming to RFC 3339
     /// are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampDefaultRejectsDifferent8601Formats_case14
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_timestamp_default_rejects_different8601_formats_case14_malformed_request(
     ) {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case2_malformed_request() {
-24133
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryDefault")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : 1.001 }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryDefault?timestamp=2011-12-03T10:15:30+01:00[Europe/Paris]"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_default(move |input: crate::input::MalformedTimestampQueryDefaultInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryDefaultOutput, crate::error::MalformedTimestampQueryDefaultError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24153
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24168
+        }
-24169
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_query_epoch_test {
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsDateTime_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case3_malformed_request() {
-24175
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : 2ABC }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryEpoch?timestamp=1985-04-12T23%3A20%3A50.52Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24195
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24210
+        }
-24211
+    }
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsDateTime_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case4_malformed_request() {
-24217
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : 0x42 }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryEpoch?timestamp=1985-04-12T23%3A20%3A50Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24237
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24252
+        }
-24253
+    }
     /// When the format is epoch-seconds, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsDateTime_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case5_malformed_request() {
-24259
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : Infinity }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryEpoch?timestamp=1996-12-19T16%3A39%3A57-08%3A00"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24279
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24294
+        }
-24295
+    }
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsHttpDate_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_http_date_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case6_malformed_request() {
-24301
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=Tue%2C%2029%20Apr%202014%2018%3A30%3A38%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24321
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24336
+        }
-24337
+    }
     /// When the format is epoch-seconds, IMF-fixdate timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsHttpDate_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case7
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_http_date_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case7_malformed_request() {
-24343
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : -Infinity }".as_bytes()),
                 ))
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=Sun%2C%2002%20Jan%202000%2020%3A34%3A56.000%20GMT".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24363
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24378
+        }
-24379
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case0
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case8
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case8_malformed_request() {
-24385
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=true"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"-Infinity\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24405
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24420
+        }
-24421
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case1
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case9
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case9_malformed_request() {
-24427
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=1515531081ABC"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : NaN }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24447
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24462
+        }
-24463
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case2
     /// Malformed values in the body should be rejected
     /// Test ID: RestJsonBodyIntegerMalformedValueRejected_case10
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_body_integer_malformed_value_rejected_case10_malformed_request() {
-24469
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=0x42"
                 .parse()
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"integerInBody\" : \"NaN\" }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24489
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24504
+        }
-24505
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case3
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case3_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case0_malformed_request() {
-24511
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/true")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=1515531081.123.456"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24528
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24543
+        }
-24544
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case4
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case4_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case1_malformed_request() {
-24550
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/1.001")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24567
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24582
+        }
-24583
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case5
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case5_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case2_malformed_request() {
-24589
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/2ABC")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=-Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24606
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24621
+        }
-24622
+    }
     /// Invalid values for epoch seconds are rejected with a 400 SerializationException
     /// Test ID: RestJsonQueryTimestampEpochRejectsMalformedValues_case6
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_query_timestamp_epoch_rejects_malformed_values_case6_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case3_malformed_request() {
-24628
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryEpoch")
                 .uri("/MalformedInteger/0x42")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryEpoch?timestamp=NaN"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_epoch(move |input: crate::input::MalformedTimestampQueryEpochInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryEpochOutput, crate::error::MalformedTimestampQueryEpochError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24645
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24660
+        }
-24661
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_timestamp_query_http_date_test {
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsDateTime_case0
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_query_timestamp_http_date_rejects_date_time_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case4_malformed_request() {
-24667
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryHttpDate")
                 .uri("/MalformedInteger/Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryHttpDate?timestamp=1985-04-12T23%3A20%3A50.52Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24684
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24699
+        }
-24700
+    }
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsDateTime_case1
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_query_timestamp_http_date_rejects_date_time_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case5_malformed_request() {
-24706
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryHttpDate")
                 .uri("/MalformedInteger/-Infinity")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryHttpDate?timestamp=1985-04-12T23%3A20%3A50Z"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24723
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24738
+        }
-24739
+    }
     /// When the format is http-date, RFC3339 timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsDateTime_case2
     /// Malformed values in the path should be rejected
     /// Test ID: RestJsonPathIntegerMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_query_timestamp_http_date_rejects_date_time_case2_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_path_integer_malformed_value_rejected_case6_malformed_request() {
-24745
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryHttpDate")
                 .uri("/MalformedInteger/NaN")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() =
                 "/MalformedTimestampQueryHttpDate?timestamp=1996-12-19T16%3A39%3A57-08%3A00"
                     .parse()
                     .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24762
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24777
+        }
-24778
+    }
     /// When the format is http-date, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsEpochSeconds_case0
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_query_timestamp_http_date_rejects_epoch_seconds_case0_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case0_malformed_request() {
-24784
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryHttpDate")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryHttpDate?timestamp=1515531081.1234"
                 .parse()
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=true".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24802
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24817
+        }
-24818
+    }
     /// When the format is http-date, epoch second timestamps are rejected with a
     /// 400 SerializationException
     /// Test ID: RestJsonQueryTimestampHttpDateRejectsEpochSeconds_case1
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case1
     #[::tokio::test]
     async fn rest_json_query_timestamp_http_date_rejects_epoch_seconds_case1_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case1_malformed_request() {
-24824
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedTimestampQueryHttpDate")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedTimestampQueryHttpDate?timestamp=1515531081"
                 .parse()
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=1.001".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_timestamp_query_http_date(move |input: crate::input::MalformedTimestampQueryHttpDateInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedTimestampQueryHttpDateOutput, crate::error::MalformedTimestampQueryHttpDateError> };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24842
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24857
+        }
-24858
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_malformed_union_test {
     /// When the union has multiple fields set, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionMultipleFieldsSet
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_malformed_union_multiple_fields_set_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case2_malformed_request() {
-24864
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedUnion")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"union\" : { \"int\": 2, \"string\": \"three\" } }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=2ABC".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24882
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24897
+        }
-24898
+    }
     /// When the union has multiple fields set, even when only one is modeled,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonMalformedUnionKnownAndUnknownFieldsSet
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_malformed_union_known_and_unknown_fields_set_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case3_malformed_request() {
-24904
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedUnion")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{ \"union\" : { \"int\": 2, \"unknownField\": \"three\" } }".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=0x42".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24922
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24937
+        }
-24938
+    }
     /// When the union has no fields set, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionNoFieldsSet
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case4
     #[::tokio::test]
     async fn rest_json_malformed_union_no_fields_set_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case4_malformed_request() {
-24944
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedUnion")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"union\" : { \"int\": null } }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-24964
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-24979
+        }
-24980
+    }
     /// When the union value is actually an array, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionValueIsArray
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case5
     #[::tokio::test]
     async fn rest_json_malformed_union_value_is_array_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case5_malformed_request() {
-24986
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedUnion")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"union\" : [\"int\"] }".as_bytes()),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=-Infinity"
                 .parse()
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-25006
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-25021
+        }
-25022
+    }
     /// When an unknown union member is received, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonMalformedUnionUnknownMember
     /// Malformed values in query parameters should be rejected
     /// Test ID: RestJsonQueryIntegerMalformedValueRejected_case6
     #[::tokio::test]
     async fn rest_json_malformed_union_unknown_member_malformed_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_query_integer_malformed_value_rejected_case6_malformed_request() {
-25028
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedUnion")
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{\n    \"union\": {\n        \"unknown\": \"hello\"\n    }\n}".as_bytes(),
                     ),
                 ))
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             *http_request.uri_mut() = "/MalformedInteger/1?integerInQuery=NaN".parse().unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_union(move |input: crate::input::MalformedUnionInput| {
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedUnionOutput };
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-25046
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-25061
+        }
-25062
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_media_type_header_test {
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderInputBase64
     #[::tokio::test]
     async fn media_type_header_input_base64_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/MediaTypeHeader")
             .method("GET")
             .header("X-Json", "dHJ1ZQ==")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .media_type_header(move |input: crate::input::MediaTypeHeaderInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::MediaTypeHeaderInput {
                             json: ::std::option::Option::Some("true".to_owned()),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::MediaTypeHeaderOutput {
                             json: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
--
+    }
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderOutputBase64
     #[::tokio::test]
     async fn media_type_header_output_base64_response() {
         let output = crate::output::MediaTypeHeaderOutput {
             json: ::std::option::Option::Some("true".to_owned()),
         };
         use ::aws_smithy_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-Json", "dHJ1ZQ==")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_no_input_and_no_output_test {
     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     async fn rest_json_no_input_and_no_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndNoOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_no_output(move |input: crate::input::NoInputAndNoOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndNoOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndNoOutputOutput {};
                         response
                     };
                     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());
--
+    }
     /// Servers should allow the accept header to be set to the
     /// default content-type.
     /// Test ID: RestJsonNoInputAllowsAccept
     #[::tokio::test]
     async fn rest_json_no_input_allows_accept_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndNoOutput")
             .method("POST")
             .header("Accept", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_no_output(move |input: crate::input::NoInputAndNoOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndNoOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndNoOutputOutput {};
                         response
                     };
                     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());
--
+    }
     /// When an operation does not define output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     async fn rest_json_no_input_and_no_output_response() {
         let output = crate::output::NoInputAndNoOutputOutput {};
         use ::aws_smithy_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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_no_input_and_output_test {
     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndOutput
     #[::tokio::test]
     async fn rest_json_no_input_and_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndOutputOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_output(move |input: crate::input::NoInputAndOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndOutputOutput {};
                         response
                     };
                     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());
--
+    }
     /// Servers should allow the accept header to be set to the
     /// default content-type.
     /// Test ID: RestJsonNoInputAndOutputAllowsAccept
     #[::tokio::test]
     async fn rest_json_no_input_and_output_allows_accept_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndOutputOutput")
             .method("POST")
             .header("Accept", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_output(move |input: crate::input::NoInputAndOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndOutputOutput {};
                         response
                     };
                     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());
--
+    }
     /// Operations that define output and do not bind anything to
     /// the payload return a JSON object in the response.
     /// Test ID: RestJsonNoInputAndOutputWithJson
     #[::tokio::test]
     async fn rest_json_no_input_and_output_with_json_response() {
         let output = crate::output::NoInputAndOutputOutput {};
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_null_and_empty_headers_server_test {
     /// Do not send null or empty headers
     /// Test ID: RestJsonNullAndEmptyHeaders
     #[::tokio::test]
     async fn rest_json_null_and_empty_headers_response() {
         let output = crate::output::NullAndEmptyHeadersServerOutput {
             a: ::std::option::Option::None,
             b: ::std::option::Option::Some("".to_owned()),
             c: ::std::option::Option::Some(vec![]),
         };
         use ::aws_smithy_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 forbidden_headers = &["X-A", "X-B", "X-C"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(
             http_response.headers(),
             forbidden_headers,
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_omits_null_serializes_empty_string_test {
     /// Serializes empty query strings
     /// Test ID: RestJsonSerializesEmptyQueryValue
     #[::tokio::test]
     async fn rest_json_serializes_empty_query_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/OmitsNullSerializesEmptyString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/OmitsNullSerializesEmptyString?Empty=".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .omits_null_serializes_empty_string(
                 move |input: crate::input::OmitsNullSerializesEmptyStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::OmitsNullSerializesEmptyStringInput {
                                 empty_string: ::std::option::Option::Some("".to_owned()),
                                 null_value: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::OmitsNullSerializesEmptyStringOutput {};
                             response
                         };
                         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());
--
+    }
     /// Servers accept static query params as empty strings.
     /// Test ID: RestJsonServersAcceptStaticQueryParamAsEmptyString
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case0
     #[::tokio::test]
     async fn rest_json_servers_accept_static_query_param_as_empty_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/OmitsNullSerializesEmptyString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/OmitsNullSerializesEmptyString?Empty".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .omits_null_serializes_empty_string(
                 move |input: crate::input::OmitsNullSerializesEmptyStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::OmitsNullSerializesEmptyStringInput {
                                 empty_string: ::std::option::Option::Some("".to_owned()),
                                 null_value: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::OmitsNullSerializesEmptyStringOutput {};
                             response
                         };
                         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());
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "true")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25102
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_omits_serializing_empty_lists_test {
     /// Supports omitting empty lists.
     /// Test ID: RestJsonOmitsEmptyListQueryValues
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case1
     #[::tokio::test]
     #[should_panic]
     async fn rest_json_omits_empty_list_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/OmitsSerializingEmptyLists")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .omits_serializing_empty_lists(
                 move |input: crate::input::OmitsSerializingEmptyListsInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::OmitsSerializingEmptyListsInput {
                                 query_string_list: ::std::option::Option::Some(vec![]),
                                 query_integer_list: ::std::option::Option::Some(vec![]),
                                 query_double_list: ::std::option::Option::Some(vec![]),
                                 query_boolean_list: ::std::option::Option::Some(vec![]),
                                 query_timestamp_list: ::std::option::Option::Some(vec![]),
                                 query_enum_list: ::std::option::Option::Some(vec![]),
                                 query_integer_enum_list: ::std::option::Option::Some(vec![]),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::OmitsSerializingEmptyListsOutput {};
                             Ok(response)
                         };
                         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());
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case1_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "1.001")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25142
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_post_player_action_test {
     /// Unit types in unions are serialized like normal structures in requests.
     /// Test ID: RestJsonInputUnionWithUnitMember
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case2
     #[::tokio::test]
     async fn rest_json_input_union_with_unit_member_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/PostPlayerAction")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"action\": {\n        \"quit\": {}\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .post_player_action(move |input: crate::input::PostPlayerActionInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::PostPlayerActionInput {
                             action: ::std::option::Option::Some(crate::model::PlayerAction::Quit),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostPlayerActionOutput {
                             action: crate::model::PlayerAction::Quit,
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case2_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "2ABC")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25182
+    }
     /// Unit types in unions are serialized like normal structures in responses.
     /// Test ID: RestJsonOutputUnionWithUnitMember
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case3
     #[::tokio::test]
     async fn rest_json_output_union_with_unit_member_response() {
         let output = crate::output::PostPlayerActionOutput {
             action: crate::model::PlayerAction::Quit,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"action\": {\n        \"quit\": {}\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case3_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "0x42")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25222
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_post_union_with_json_name_test {
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameRequest1
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case4
     #[::tokio::test]
     async fn post_union_with_json_name_request1_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/PostUnionWithJsonName")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"value\": {\n        \"FOO\": \"hi\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .post_union_with_json_name(move |input: crate::input::PostUnionWithJsonNameInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::PostUnionWithJsonNameInput {
                             value: ::std::option::Option::Some(
                                 crate::model::UnionWithJsonName::Foo("hi".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostUnionWithJsonNameOutput {
                             value: crate::model::UnionWithJsonName::Foo("".to_owned()),
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case4_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25262
+    }
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameRequest2
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case5
     #[::tokio::test]
     async fn post_union_with_json_name_request2_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/PostUnionWithJsonName")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"value\": {\n        \"_baz\": \"hi\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .post_union_with_json_name(move |input: crate::input::PostUnionWithJsonNameInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::PostUnionWithJsonNameInput {
                             value: ::std::option::Option::Some(
                                 crate::model::UnionWithJsonName::Baz("hi".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostUnionWithJsonNameOutput {
                             value: crate::model::UnionWithJsonName::Foo("".to_owned()),
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case5_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "-Infinity")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25302
+    }
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameRequest3
     /// Malformed values in headers should be rejected
     /// Test ID: RestJsonHeaderIntegerMalformedValueRejected_case6
     #[::tokio::test]
     async fn post_union_with_json_name_request3_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/PostUnionWithJsonName")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"value\": {\n        \"bar\": \"hi\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .post_union_with_json_name(move |input: crate::input::PostUnionWithJsonNameInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::PostUnionWithJsonNameInput {
                             value: ::std::option::Option::Some(
                                 crate::model::UnionWithJsonName::Bar("hi".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostUnionWithJsonNameOutput {
                             value: crate::model::UnionWithJsonName::Foo("".to_owned()),
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_header_integer_malformed_value_rejected_case6_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedInteger/1")
                 .method("POST")
                 .header("integerInHeader", "NaN")
                 .body(::aws_smithy_http_server::body::Body::empty())
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_integer(move |input: crate::input::MalformedIntegerInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::MalformedIntegerOutput, crate::error::MalformedIntegerError> };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25342
+    }
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse1
     #[::tokio::test]
     async fn post_union_with_json_name_response1_response() {
         let output = crate::output::PostUnionWithJsonNameOutput {
             value: crate::model::UnionWithJsonName::Foo("hi".to_owned()),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"value\": {\n        \"FOO\": \"hi\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+}
-+
 const CONTENT_TYPE_MALFORMEDREQUESTBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedRequestBodyInput`](crate::input::MalformedRequestBodyInput) using modelled bindings.
     pub struct MalformedRequestBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedRequestBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-25351
+    }
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse2
     #[::tokio::test]
     async fn post_union_with_json_name_response2_response() {
         let output = crate::output::PostUnionWithJsonNameOutput {
             value: crate::model::UnionWithJsonName::Baz("hi".to_owned()),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"value\": {\n        \"_baz\": \"hi\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+}
-+
 impl std::future::Future for MalformedRequestBodyInputFuture {
     type Output = Result<
         crate::input::MalformedRequestBodyInput,
         ::aws_smithy_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)
-25366
+    }
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse3
     #[::tokio::test]
     async fn post_union_with_json_name_response3_response() {
         let output = crate::output::PostUnionWithJsonNameOutput {
             value: crate::model::UnionWithJsonName::Bar("hi".to_owned()),
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRequestBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRequestBodyInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDREQUESTBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_malformed_request_body::de_malformed_request_body_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"value\": {\n        \"bar\": \"hi\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         MalformedRequestBodyInputFuture {
             inner: Box::pin(fut),
-+
+        }
-25409
+    }
-25410
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_query_params_as_string_list_map_test {
     /// Servers put all query params in map
     /// Test ID: RestJsonServersQueryParamsStringListMap
     #[::tokio::test]
     async fn rest_json_servers_query_params_string_list_map_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StringListMap")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/StringListMap?corge=named&baz=bar&baz=qux"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .query_params_as_string_list_map(
                 move |input: crate::input::QueryParamsAsStringListMapInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::QueryParamsAsStringListMapInput {
                                 qux: ::std::option::Option::Some("named".to_owned()),
                                 foo: ::std::option::Option::Some({
                                     let mut ret = ::std::collections::HashMap::new();
                                     ret.insert("corge".to_owned(), vec!["named".to_owned()]);
                                     ret.insert(
                                         "baz".to_owned(),
                                         vec!["bar".to_owned(), "qux".to_owned()],
                                     );
                                     ret
                                 }),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::QueryParamsAsStringListMapOutput {};
                             response
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRequestBodyOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_request_body::ser_malformed_request_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-25423
+                    }
                 },
--
+            )
             .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());
-25424
+    }
-25425
+}
 #[cfg(test)]
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_query_precedence_test {
     /// Servers put all query params in map
     /// Test ID: RestJsonServersPutAllQueryParamsInMap
     #[::tokio::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_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .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::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::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 response = crate::output::QueryPrecedenceOutput {};
                         response
                     };
                     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());
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_recursive_shapes_test {
     /// Serializes recursive structures
     /// Test ID: RestJsonRecursiveShapes
     #[::tokio::test]
     async fn rest_json_recursive_shapes_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/RecursiveShapes")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"nested\": {\n        \"foo\": \"Foo1\",\n        \"nested\": {\n            \"bar\": \"Bar1\",\n            \"recursiveMember\": {\n                \"foo\": \"Foo2\",\n                \"nested\": {\n                    \"bar\": \"Bar2\"\n                }\n            }\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .recursive_shapes(move |input: crate::input::RecursiveShapesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { let expected =
             crate::input::RecursiveShapesInput {
                 nested:
                     ::std::option::Option::Some(
                         crate::model::RecursiveShapesInputOutputNested1 {
                             foo:
                                 ::std::option::Option::Some(
                                     "Foo1".to_owned()
--
+                                )
--
+                            ,
                             nested:
                                 ::std::option::Option::Some(
                                     ::std::boxed::Box::new(
                                         crate::model::RecursiveShapesInputOutputNested2 {
                                             bar:
                                                 ::std::option::Option::Some(
                                                     "Bar1".to_owned()
--
+                                                )
--
+                                            ,
                                             recursive_member:
                                                 ::std::option::Option::Some(
                                                     crate::model::RecursiveShapesInputOutputNested1 {
                                                         foo:
                                                             ::std::option::Option::Some(
                                                                 "Foo2".to_owned()
--
+                                                            )
--
+                                                        ,
                                                         nested:
                                                             ::std::option::Option::Some(
                                                                 ::std::boxed::Box::new(
                                                                     crate::model::RecursiveShapesInputOutputNested2 {
                                                                         bar:
                                                                             ::std::option::Option::Some(
                                                                                 "Bar2".to_owned()
--
+                                                                            )
--
+                                                                        ,
                                                                         recursive_member:
                                                                             ::std::option::Option::None
--
+                                                                        ,
--
+                                                                    }
--
+                                                                )
--
+                                                            )
--
+                                                        ,
--
+                                                    }
--
+                                                )
--
+                                            ,
--
+                                        }
--
+                                    )
--
+                                )
--
+                            ,
--
+                        }
--
+                    )
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input, expected);
         let response =
             crate::output::RecursiveShapesOutput {
                 nested:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         response };
                                 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());
--
+    }
     /// Serializes recursive structures
     /// Test ID: RestJsonRecursiveShapes
 mod malformed_request_body_test {
-+
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case0
     #[::tokio::test]
     async fn rest_json_recursive_shapes_response() {
         let output = crate::output::RecursiveShapesOutput {
             nested: ::std::option::Option::Some(crate::model::RecursiveShapesInputOutputNested1 {
                 foo: ::std::option::Option::Some("Foo1".to_owned()),
                 nested: ::std::option::Option::Some(::std::boxed::Box::new(
                     crate::model::RecursiveShapesInputOutputNested2 {
                         bar: ::std::option::Option::Some("Bar1".to_owned()),
                         recursive_member: ::std::option::Option::Some(
                             crate::model::RecursiveShapesInputOutputNested1 {
                                 foo: ::std::option::Option::Some("Foo2".to_owned()),
                                 nested: ::std::option::Option::Some(::std::boxed::Box::new(
                                     crate::model::RecursiveShapesInputOutputNested2 {
                                         bar: ::std::option::Option::Some("Bar2".to_owned()),
                                         recursive_member: ::std::option::Option::None,
                                     },
                                 )),
                             },
                         ),
                     },
                 )),
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"nested\": {\n        \"foo\": \"Foo1\",\n        \"nested\": {\n            \"bar\": \"Bar1\",\n            \"recursiveMember\": {\n                \"foo\": \"Foo2\",\n                \"nested\": {\n                    \"bar\": \"Bar2\"\n                }\n            }\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{[".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25473
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_simple_scalar_properties_test {
     /// Serializes simple scalar properties
     /// Test ID: RestJsonSimpleScalarProperties
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case1
     #[::tokio::test]
     async fn rest_json_simple_scalar_properties_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SimpleScalarProperties")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .header("X-Foo", "Foo")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringValue\": \"string\",\n    \"trueBooleanValue\": true,\n    \"falseBooleanValue\": false,\n    \"byteValue\": 1,\n    \"shortValue\": 2,\n    \"integerValue\": 3,\n    \"longValue\": 4,\n    \"floatValue\": 5.5,\n    \"DoubleDribble\": 6.5\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::SimpleScalarPropertiesInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             true_boolean_value: ::std::option::Option::Some(true),
                             false_boolean_value: ::std::option::Option::Some(false),
                             byte_value: ::std::option::Option::Some(1),
                             short_value: ::std::option::Option::Some(2),
                             integer_value: ::std::option::Option::Some(3),
                             long_value: ::std::option::Option::Some(4),
                             float_value: ::std::option::Option::Some(5.5_f32),
                             double_value: ::std::option::Option::Some(6.5_f64),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.string_value,
                             expected.string_value,
                             "Unexpected value for `string_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.true_boolean_value,
                             expected.true_boolean_value,
                             "Unexpected value for `true_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.false_boolean_value,
                             expected.false_boolean_value,
                             "Unexpected value for `false_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.byte_value,
                             expected.byte_value,
                             "Unexpected value for `byte_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short_value,
                             expected.short_value,
                             "Unexpected value for `short_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer_value,
                             expected.integer_value,
                             "Unexpected value for `integer_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long_value,
                             expected.long_value,
                             "Unexpected value for `long_value`"
                         );
                         assert!(
                             input.float_value.float_equals(&expected.float_value),
                             "Unexpected value for `float_value` {:?} vs. {:?}",
                             expected.float_value,
                             input.float_value
                         );
                         assert!(
                             input.double_value.float_equals(&expected.double_value),
                             "Unexpected value for `double_value` {:?} vs. {:?}",
                             expected.double_value,
                             input.double_value
                         );
                         let response = crate::output::SimpleScalarPropertiesOutput {
                             foo: ::std::option::Option::None,
                             string_value: ::std::option::Option::None,
                             true_boolean_value: ::std::option::Option::None,
                             false_boolean_value: ::std::option::Option::None,
                             byte_value: ::std::option::Option::None,
                             short_value: ::std::option::Option::None,
                             integer_value: ::std::option::Option::None,
                             long_value: ::std::option::Option::None,
                             float_value: ::std::option::Option::None,
                             double_value: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case1_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{ \"int\": 10 }abc".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25516
+    }
     /// Rest Json should not deserialize null structure values
     /// Test ID: RestJsonServersDontSerializeNullStructureValues
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case2
     #[::tokio::test]
     async fn rest_json_servers_dont_serialize_null_structure_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SimpleScalarProperties")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"stringValue\": null\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::SimpleScalarPropertiesInput {
                             foo: ::std::option::Option::None,
                             string_value: ::std::option::Option::None,
                             true_boolean_value: ::std::option::Option::None,
                             false_boolean_value: ::std::option::Option::None,
                             byte_value: ::std::option::Option::None,
                             short_value: ::std::option::Option::None,
                             integer_value: ::std::option::Option::None,
                             long_value: ::std::option::Option::None,
                             float_value: ::std::option::Option::None,
                             double_value: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.string_value,
                             expected.string_value,
                             "Unexpected value for `string_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.true_boolean_value,
                             expected.true_boolean_value,
                             "Unexpected value for `true_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.false_boolean_value,
                             expected.false_boolean_value,
                             "Unexpected value for `false_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.byte_value,
                             expected.byte_value,
                             "Unexpected value for `byte_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short_value,
                             expected.short_value,
                             "Unexpected value for `short_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer_value,
                             expected.integer_value,
                             "Unexpected value for `integer_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long_value,
                             expected.long_value,
                             "Unexpected value for `long_value`"
                         );
                         assert!(
                             input.float_value.float_equals(&expected.float_value),
                             "Unexpected value for `float_value` {:?} vs. {:?}",
                             expected.float_value,
                             input.float_value
                         );
                         assert!(
                             input.double_value.float_equals(&expected.double_value),
                             "Unexpected value for `double_value` {:?} vs. {:?}",
                             expected.double_value,
                             input.double_value
                         );
                         let response = crate::output::SimpleScalarPropertiesOutput {
                             foo: ::std::option::Option::None,
                             string_value: ::std::option::Option::None,
                             true_boolean_value: ::std::option::Option::None,
                             false_boolean_value: ::std::option::Option::None,
                             byte_value: ::std::option::Option::None,
                             short_value: ::std::option::Option::None,
                             integer_value: ::std::option::Option::None,
                             long_value: ::std::option::Option::None,
                             float_value: ::std::option::Option::None,
                             double_value: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case2_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("abc{ \"int\": 10 }".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25559
+    }
     /// Supports handling NaN float values.
     /// Test ID: RestJsonSupportsNaNFloatInputs
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case3
     #[::tokio::test]
     async fn rest_json_supports_na_n_float_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SimpleScalarProperties")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"floatValue\": \"NaN\",\n    \"DoubleDribble\": \"NaN\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::SimpleScalarPropertiesInput {
                 float_value:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                    )
--
+                ,
                 double_value:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
--
+                    )
--
+                ,
                 foo:
                     ::std::option::Option::None
--
+                ,
                 string_value:
                     ::std::option::Option::None
--
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 byte_value:
                     ::std::option::Option::None
--
+                ,
                 short_value:
                     ::std::option::Option::None
--
+                ,
                 integer_value:
                     ::std::option::Option::None
--
+                ,
                 long_value:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.foo, expected.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(input.string_value, expected.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(input.true_boolean_value, expected.true_boolean_value, "Unexpected value for `true_boolean_value`");
         ::pretty_assertions::assert_eq!(input.false_boolean_value, expected.false_boolean_value, "Unexpected value for `false_boolean_value`");
         ::pretty_assertions::assert_eq!(input.byte_value, expected.byte_value, "Unexpected value for `byte_value`");
         ::pretty_assertions::assert_eq!(input.short_value, expected.short_value, "Unexpected value for `short_value`");
         ::pretty_assertions::assert_eq!(input.integer_value, expected.integer_value, "Unexpected value for `integer_value`");
         ::pretty_assertions::assert_eq!(input.long_value, expected.long_value, "Unexpected value for `long_value`");
         assert!(input.float_value.float_equals(&expected.float_value),
                                             "Unexpected value for `float_value` {:?} vs. {:?}", expected.float_value, input.float_value);
         assert!(input.double_value.float_equals(&expected.double_value),
                                             "Unexpected value for `double_value` {:?} vs. {:?}", expected.double_value, input.double_value);
         let response =
             crate::output::SimpleScalarPropertiesOutput {
                 foo:
                     ::std::option::Option::None
--
+                ,
                 string_value:
                     ::std::option::Option::None
--
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 byte_value:
                     ::std::option::Option::None
--
+                ,
                 short_value:
                     ::std::option::Option::None
--
+                ,
                 integer_value:
                     ::std::option::Option::None
--
+                ,
                 long_value:
                     ::std::option::Option::None
--
+                ,
                 float_value:
                     ::std::option::Option::None
--
+                ,
                 double_value:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         response };
                                 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());
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case3_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{\n    \"int\": 10 // the integer should be 10\n}".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25604
+    }
     /// Supports handling Infinity float values.
     /// Test ID: RestJsonSupportsInfinityFloatInputs
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case4
     #[::tokio::test]
     async fn rest_json_supports_infinity_float_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SimpleScalarProperties")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"floatValue\": \"Infinity\",\n    \"DoubleDribble\": \"Infinity\"\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::SimpleScalarPropertiesInput {
                 float_value:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 double_value:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 foo:
                     ::std::option::Option::None
--
+                ,
                 string_value:
                     ::std::option::Option::None
--
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 byte_value:
                     ::std::option::Option::None
--
+                ,
                 short_value:
                     ::std::option::Option::None
--
+                ,
                 integer_value:
                     ::std::option::Option::None
--
+                ,
                 long_value:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.foo, expected.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(input.string_value, expected.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(input.true_boolean_value, expected.true_boolean_value, "Unexpected value for `true_boolean_value`");
         ::pretty_assertions::assert_eq!(input.false_boolean_value, expected.false_boolean_value, "Unexpected value for `false_boolean_value`");
         ::pretty_assertions::assert_eq!(input.byte_value, expected.byte_value, "Unexpected value for `byte_value`");
         ::pretty_assertions::assert_eq!(input.short_value, expected.short_value, "Unexpected value for `short_value`");
         ::pretty_assertions::assert_eq!(input.integer_value, expected.integer_value, "Unexpected value for `integer_value`");
         ::pretty_assertions::assert_eq!(input.long_value, expected.long_value, "Unexpected value for `long_value`");
         assert!(input.float_value.float_equals(&expected.float_value),
                                             "Unexpected value for `float_value` {:?} vs. {:?}", expected.float_value, input.float_value);
         assert!(input.double_value.float_equals(&expected.double_value),
                                             "Unexpected value for `double_value` {:?} vs. {:?}", expected.double_value, input.double_value);
         let response =
             crate::output::SimpleScalarPropertiesOutput {
                 foo:
                     ::std::option::Option::None
--
+                ,
                 string_value:
                     ::std::option::Option::None
--
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 byte_value:
                     ::std::option::Option::None
--
+                ,
                 short_value:
                     ::std::option::Option::None
--
+                ,
                 integer_value:
                     ::std::option::Option::None
--
+                ,
                 long_value:
                     ::std::option::Option::None
--
+                ,
                 float_value:
                     ::std::option::Option::None
--
+                ,
                 double_value:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         response };
                                 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());
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case4_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static(
                         "{\n    \"int\": 10 /* the integer should be 10 */\n}".as_bytes(),
                     ),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-+
+    }
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case5
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case5_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{\"int\" :\\u{000c}10}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25692
+    }
     /// Supports handling -Infinity float values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatInputs
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case6
     #[::tokio::test]
     async fn rest_json_supports_negative_infinity_float_inputs_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SimpleScalarProperties")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"floatValue\": \"-Infinity\",\n    \"DoubleDribble\": \"-Infinity\"\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::SimpleScalarPropertiesInput {
                 float_value:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 double_value:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
--
+                    )
--
+                ,
                 foo:
                     ::std::option::Option::None
--
+                ,
                 string_value:
                     ::std::option::Option::None
--
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 byte_value:
                     ::std::option::Option::None
--
+                ,
                 short_value:
                     ::std::option::Option::None
--
+                ,
                 integer_value:
                     ::std::option::Option::None
--
+                ,
                 long_value:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         ::pretty_assertions::assert_eq!(input.foo, expected.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(input.string_value, expected.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(input.true_boolean_value, expected.true_boolean_value, "Unexpected value for `true_boolean_value`");
         ::pretty_assertions::assert_eq!(input.false_boolean_value, expected.false_boolean_value, "Unexpected value for `false_boolean_value`");
         ::pretty_assertions::assert_eq!(input.byte_value, expected.byte_value, "Unexpected value for `byte_value`");
         ::pretty_assertions::assert_eq!(input.short_value, expected.short_value, "Unexpected value for `short_value`");
         ::pretty_assertions::assert_eq!(input.integer_value, expected.integer_value, "Unexpected value for `integer_value`");
         ::pretty_assertions::assert_eq!(input.long_value, expected.long_value, "Unexpected value for `long_value`");
         assert!(input.float_value.float_equals(&expected.float_value),
                                             "Unexpected value for `float_value` {:?} vs. {:?}", expected.float_value, input.float_value);
         assert!(input.double_value.float_equals(&expected.double_value),
                                             "Unexpected value for `double_value` {:?} vs. {:?}", expected.double_value, input.double_value);
         let response =
             crate::output::SimpleScalarPropertiesOutput {
                 foo:
                     ::std::option::Option::None
--
+                ,
                 string_value:
                     ::std::option::Option::None
--
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
--
+                ,
                 byte_value:
                     ::std::option::Option::None
--
+                ,
                 short_value:
                     ::std::option::Option::None
--
+                ,
                 integer_value:
                     ::std::option::Option::None
--
+                ,
                 long_value:
                     ::std::option::Option::None
--
+                ,
                 float_value:
                     ::std::option::Option::None
--
+                ,
                 double_value:
                     ::std::option::Option::None
--
+                ,
--
+            }
--
+        ;
         response };
                                 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());
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case6_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{'int': 10}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25735
+    }
     /// Serializes simple scalar properties
     /// Test ID: RestJsonSimpleScalarProperties
     /// When the request body is not valid JSON, the response should be a 400
     /// SerializationException.
     /// Test ID: RestJsonInvalidJsonBody_case7
     #[::tokio::test]
     async fn rest_json_simple_scalar_properties_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             string_value: ::std::option::Option::Some("string".to_owned()),
             true_boolean_value: ::std::option::Option::Some(true),
             false_boolean_value: ::std::option::Option::Some(false),
             byte_value: ::std::option::Option::Some(1),
             short_value: ::std::option::Option::Some(2),
             integer_value: ::std::option::Option::Some(3),
             long_value: ::std::option::Option::Some(4),
             float_value: ::std::option::Option::Some(5.5_f32),
             double_value: ::std::option::Option::Some(6.5_f64),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json"), ("X-Foo", "Foo")];
         ::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, "{\n    \"stringValue\": \"string\",\n    \"trueBooleanValue\": true,\n    \"falseBooleanValue\": false,\n    \"byteValue\": 1,\n    \"shortValue\": 2,\n    \"integerValue\": 3,\n    \"longValue\": 4,\n    \"floatValue\": 5.5,\n    \"DoubleDribble\": 6.5\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_json_body_case7_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("{\"int\": 10,}".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25778
+    }
     /// Rest Json should not serialize null structure values
     /// Test ID: RestJsonServersDontSerializeNullStructureValues
     /// When the request body is technically valid, but cannot map to a Smithy structure,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonTechnicallyValidJsonBody_case0
     #[::tokio::test]
     async fn rest_json_servers_dont_serialize_null_structure_values_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             string_value: ::std::option::Option::None,
             foo: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
             float_value: ::std::option::Option::None,
             double_value: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_technically_valid_json_body_case0_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("[{ \"int\": 10}]".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25821
+    }
     /// Supports handling NaN float values.
     /// Test ID: RestJsonSupportsNaNFloatInputs
     /// When the request body is technically valid, but cannot map to a Smithy structure,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonTechnicallyValidJsonBody_case1
     #[::tokio::test]
     async fn rest_json_supports_na_n_float_inputs_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             float_value: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             double_value: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             foo: ::std::option::Option::None,
             string_value: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"floatValue\": \"NaN\",\n    \"DoubleDribble\": \"NaN\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_technically_valid_json_body_case1_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("10".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25864
+    }
     /// Supports handling Infinity float values.
     /// Test ID: RestJsonSupportsInfinityFloatInputs
     /// When the request body is technically valid, but cannot map to a Smithy structure,
     /// the response should be a 400 SerializationException.
     /// Test ID: RestJsonTechnicallyValidJsonBody_case2
     #[::tokio::test]
     async fn rest_json_supports_infinity_float_inputs_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             float_value: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             double_value: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             foo: ::std::option::Option::None,
             string_value: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"floatValue\": \"Infinity\",\n    \"DoubleDribble\": \"Infinity\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
     #[::tracing_test::traced_test]
     async fn rest_json_technically_valid_json_body_case2_malformed_request() {
-+
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
                 .uri("/MalformedRequestBody")
                 .method("POST")
                 .header("content-type", "application/json")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::from_static("null".as_bytes()),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RestJsonConfig::builder().build();
             let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                             .malformed_request_body(move |input: crate::input::MalformedRequestBodyInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::MalformedRequestBodyOutput };
                                     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");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let expected_headers = [("x-amzn-errortype", "SerializationException")];
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
                 http_response.headers(),
                 expected_headers,
             ));
-+
+        }
-25907
+    }
     /// Supports handling -Infinity float values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     async fn rest_json_supports_negative_infinity_float_inputs_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             float_value: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             double_value: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             foo: ::std::option::Option::None,
             string_value: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
-+
+}
-+
 const CONTENT_TYPE_HTTPCHECKSUMREQUIRED: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpChecksumRequiredInput`](crate::input::HttpChecksumRequiredInput) using modelled bindings.
     pub struct HttpChecksumRequiredInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpChecksumRequiredInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for HttpChecksumRequiredInputFuture {
     type Output = Result<
         crate::input::HttpChecksumRequiredInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpChecksumRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpChecksumRequiredInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPCHECKSUMREQUIRED,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_http_checksum_required::de_http_checksum_required_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"floatValue\": \"-Infinity\",\n    \"DoubleDribble\": \"-Infinity\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         HttpChecksumRequiredInputFuture {
             inner: Box::pin(fut),
-+
+        }
-25974
+    }
-25975
+}
 #[cfg(test)]
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpChecksumRequiredOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_checksum_required::ser_http_checksum_required_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_sparse_json_lists_test {
     /// Serializes null values in sparse lists
     /// Test ID: RestJsonSparseListsSerializeNull
 #[cfg(test)]
 mod http_checksum_required_test {
-+
     /// Adds Content-MD5 header
     /// Test ID: RestJsonHttpChecksumRequired
     #[::tokio::test]
     async fn rest_json_sparse_lists_serialize_null_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_http_checksum_required_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SparseJsonLists")
             .method("PUT")
             .uri("/HttpChecksumRequired")
             .method("POST")
             .header("Content-MD5", "iB0/3YSo7maijL0IGOgA9g==")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"sparseStringList\": [\n        null,\n        \"hi\"\n    ]\n}"
                         .as_bytes(),
                     "{\n    \"foo\":\"base64 encoded md5 checksum\"\n}\n".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_lists(move |input: crate::input::SparseJsonListsInput| {
             .http_checksum_required(move |input: crate::input::HttpChecksumRequiredInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonListsInput {
                             sparse_string_list: ::std::option::Option::Some(vec![
                                 ::std::option::Option::None,
                                 ::std::option::Option::Some("hi".to_owned()),
                             ]),
                         let expected = crate::input::HttpChecksumRequiredInput {
                             foo: ::std::option::Option::Some(
                                 "base64 encoded md5 checksum".to_owned(),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonListsOutput {
                             sparse_string_list: ::std::option::Option::None,
                         let response = crate::output::HttpChecksumRequiredOutput {
                             foo: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-26034
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-26044
+    }
     /// Serializes null values in sparse lists
     /// Test ID: RestJsonSparseListsSerializeNull
     #[::tokio::test]
     async fn rest_json_sparse_lists_serialize_null_response() {
         let output = crate::output::SparseJsonListsOutput {
             sparse_string_list: ::std::option::Option::Some(vec![
                 ::std::option::Option::None,
                 ::std::option::Option::Some("hi".to_owned()),
             ]),
-+
+}
-+
 const CONTENT_TYPE_HOSTWITHPATHOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HostWithPathOperationInput`](crate::input::HostWithPathOperationInput) using modelled bindings.
     pub struct HostWithPathOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HostWithPathOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for HostWithPathOperationInputFuture {
     type Output = Result<
         crate::input::HostWithPathOperationInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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()
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"sparseStringList\": [\n        null,\n        \"hi\"\n    ]\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-26111
+    }
-26112
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_sparse_json_maps_test {
     /// Serializes JSON maps
     /// Test ID: RestJsonSparseJsonMaps
     #[::tokio::test]
     async fn rest_json_sparse_json_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_struct_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "foo".to_owned(),
                                     ::std::option::Option::Some(crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("there".to_owned()),
                                     }),
                                 );
                                 ret.insert(
                                     "baz".to_owned(),
                                     ::std::option::Option::Some(crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("bye".to_owned()),
                                     }),
                                 );
                                 ret
                             }),
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HostWithPathOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-26126
+    }
     /// Serializes JSON map values in sparse maps
     /// Test ID: RestJsonSerializesSparseNullMapValues
     #[::tokio::test]
     async fn rest_json_serializes_sparse_null_map_values_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseBooleanMap\": {\n        \"x\": null\n    },\n    \"sparseNumberMap\": {\n        \"x\": null\n    },\n    \"sparseStringMap\": {\n        \"x\": null\n    },\n    \"sparseStructMap\": {\n        \"x\": null\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_boolean_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_number_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_string_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
-+
+}
-+
 const CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput) using modelled bindings.
     pub struct EndpointWithHostLabelOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointWithHostLabelOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-26135
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInSparseMaps
     #[::tokio::test]
     async fn rest_json_serializes_zero_values_in_sparse_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseNumberMap\": {\n        \"x\": 0\n    },\n    \"sparseBooleanMap\": {\n        \"x\": false\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_number_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::Some(0));
                                 ret
                             }),
                             sparse_boolean_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::Some(false));
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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());
-+
+}
-+
 impl std::future::Future for EndpointWithHostLabelOperationInputFuture {
     type Output = Result<
         crate::input::EndpointWithHostLabelOperationInput,
         ::aws_smithy_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)
-26150
+    }
     /// A request that contains a sparse map of sets
     /// Test ID: RestJsonSerializesSparseSetMap
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         EndpointWithHostLabelOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointWithHostLabelOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EndpointWithHostLabelOperationError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_with_host_label_operation_test {
-+
     /// Operations can prepend to the given host if they define the
     /// endpoint trait, and can use the host label trait to define
     /// further customization based on user input.
     /// Test ID: RestJsonEndpointTraitWithHostLabel
     #[::tokio::test]
     async fn rest_json_serializes_sparse_set_map_request() {
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_endpoint_trait_with_host_label_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}".as_bytes()))).unwrap();
         let mut http_request = http::Request::builder()
             .uri("/EndpointWithHostLabelOperation")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\"label\": \"bar\"}".as_bytes()),
             ))
             .unwrap();
         todo!("endpoint trait not supported yet");
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_set_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "x".to_owned(),
                                     ::std::option::Option::Some(
                                         vec![].try_into().expect("this is only used in tests"),
                                     ),
                                 );
                                 ret.insert(
                                     "y".to_owned(),
                                     ::std::option::Option::Some(
                                         vec!["a".to_owned(), "b".to_owned()]
                                             .try_into()
                                             .expect("this is only used in tests"),
                                     ),
                                 );
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
             .endpoint_with_host_label_operation(
                 move |input: crate::input::EndpointWithHostLabelOperationInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EndpointWithHostLabelOperationInput {
                                 label: "bar".to_owned(),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::EndpointWithHostLabelOperationOutput {};
                             Ok(response)
                         };
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
--
+                }
             })
                         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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-26279
+    }
     /// A request that contains a sparse map of sets.
     /// Test ID: RestJsonSerializesSparseSetMapAndRetainsNull
-+
+}
-+
 const CONTENT_TYPE_ENDPOINTOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EndpointOperationInput`](crate::input::EndpointOperationInput) using modelled bindings.
     pub struct EndpointOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for EndpointOperationInputFuture {
     type Output = Result<
         crate::input::EndpointOperationInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         EndpointOperationInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointOperationOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod endpoint_operation_test {
-+
     /// Operations can prepend to the given host if they define the
     /// endpoint trait.
     /// Test ID: RestJsonEndpointTrait
     #[::tokio::test]
     async fn rest_json_serializes_sparse_set_map_and_retains_null_request() {
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_endpoint_trait_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}".as_bytes()))).unwrap();
         let mut http_request = http::Request::builder()
             .uri("/EndpointOperation")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         todo!("endpoint trait not supported yet");
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
             .endpoint_operation(move |input: crate::input::EndpointOperationInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_set_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "x".to_owned(),
                                     ::std::option::Option::Some(
                                         vec![].try_into().expect("this is only used in tests"),
                                     ),
                                 );
                                 ret.insert(
                                     "y".to_owned(),
                                     ::std::option::Option::Some(
                                         vec!["a".to_owned(), "b".to_owned()]
                                             .try_into()
                                             .expect("this is only used in tests"),
                                     ),
                                 );
                                 ret.insert("z".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                         };
                         let expected = crate::input::EndpointOperationInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                         let response = crate::output::EndpointOperationOutput {};
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-26403
+                }
             })
             .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());
--
+    }
     /// Deserializes JSON maps
     /// Test ID: RestJsonSparseJsonMaps
     #[::tokio::test]
     async fn rest_json_sparse_json_maps_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_struct_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     ::std::option::Option::Some(crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("there".to_owned()),
                     }),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     ::std::option::Option::Some(crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("bye".to_owned()),
                     }),
                 );
                 ret
             }),
             sparse_number_map: ::std::option::Option::None,
             sparse_boolean_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
             sparse_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n   }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-26413
+    }
     /// Deserializes null JSON map values
     /// Test ID: RestJsonDeserializesSparseNullMapValues
     #[::tokio::test]
     async fn rest_json_deserializes_sparse_null_map_values_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_boolean_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_number_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_string_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_struct_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseBooleanMap\": {\n        \"x\": null\n    },\n    \"sparseNumberMap\": {\n        \"x\": null\n    },\n    \"sparseStringMap\": {\n        \"x\": null\n    },\n    \"sparseStructMap\": {\n        \"x\": null\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+}
-+
 const CONTENT_TYPE_POSTUNIONWITHJSONNAME: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PostUnionWithJsonNameInput`](crate::input::PostUnionWithJsonNameInput) using modelled bindings.
     pub struct PostUnionWithJsonNameInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostUnionWithJsonNameInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-26422
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonDeserializesZeroValuesInSparseMaps
     #[::tokio::test]
     async fn rest_json_deserializes_zero_values_in_sparse_maps_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_number_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(0));
                 ret
             }),
             sparse_boolean_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(false));
                 ret
             }),
             sparse_struct_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
             sparse_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseNumberMap\": {\n        \"x\": 0\n    },\n    \"sparseBooleanMap\": {\n        \"x\": false\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+}
-+
 impl std::future::Future for PostUnionWithJsonNameInputFuture {
     type Output = Result<
         crate::input::PostUnionWithJsonNameInput,
         ::aws_smithy_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)
-26437
+    }
     /// A response that contains a sparse map of sets
     /// Test ID: RestJsonDeserializesSparseSetMap
     #[::tokio::test]
     async fn rest_json_deserializes_sparse_set_map_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_set_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "x".to_owned(),
                     ::std::option::Option::Some(
                         vec![].try_into().expect("this is only used in tests"),
                     ),
                 );
                 ret.insert(
                     "y".to_owned(),
                     ::std::option::Option::Some(
                         vec!["a".to_owned(), "b".to_owned()]
                             .try_into()
                             .expect("this is only used in tests"),
                     ),
                 );
                 ret
             }),
             sparse_struct_map: ::std::option::Option::None,
             sparse_number_map: ::std::option::Option::None,
             sparse_boolean_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
-+
+}
-+
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostUnionWithJsonNameInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostUnionWithJsonNameInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_POSTUNIONWITHJSONNAME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         PostUnionWithJsonNameInputFuture {
             inner: Box::pin(fut),
-+
+        }
-26480
+    }
     /// A response that contains a sparse map of sets.
     /// Test ID: RestJsonDeserializesSparseSetMapAndRetainsNull
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostUnionWithJsonNameOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_post_union_with_json_name::ser_post_union_with_json_name_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod post_union_with_json_name_test {
-+
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameRequest1
     #[::tokio::test]
     async fn rest_json_deserializes_sparse_set_map_and_retains_null_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_set_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "x".to_owned(),
                     ::std::option::Option::Some(
                         vec![].try_into().expect("this is only used in tests"),
                     ),
                 );
                 ret.insert(
                     "y".to_owned(),
                     ::std::option::Option::Some(
                         vec!["a".to_owned(), "b".to_owned()]
                             .try_into()
                             .expect("this is only used in tests"),
                     ),
                 );
                 ret.insert("z".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_struct_map: ::std::option::Option::None,
             sparse_number_map: ::std::option::Option::None,
             sparse_boolean_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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())
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_request1_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/PostUnionWithJsonName")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"value\": {\n        \"FOO\": \"hi\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .post_union_with_json_name(move |input: crate::input::PostUnionWithJsonNameInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::PostUnionWithJsonNameInput {
                             value: ::std::option::Option::Some(
                                 crate::model::UnionWithJsonName::Foo("hi".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostUnionWithJsonNameOutput {
                             value: crate::model::UnionWithJsonName::Foo("".to_owned()),
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-+
+                }
             })
             .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(&body, "{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
             .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"
         );
-26549
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_streaming_traits_test {
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithBlob
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameRequest2
     #[::tokio::test]
     async fn rest_json_streaming_traits_with_blob_request() {
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_request2_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraits")
             .uri("/PostUnionWithJsonName")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .header("X-Foo", "Foo")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"value\": {\n        \"_baz\": \"hi\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits(move |input: crate::input::StreamingTraitsInput| {
             .post_union_with_json_name(move |input: crate::input::PostUnionWithJsonNameInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::StreamingTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(
                                 b"blobby blob blob",
                         let expected = crate::input::PostUnionWithJsonNameInput {
                             value: ::std::option::Option::Some(
                                 crate::model::UnionWithJsonName::Baz("hi".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.blob.collect().await.unwrap().into_bytes(),
                             expected.blob.collect().await.unwrap().into_bytes()
                         );
                         let response = crate::output::StreamingTraitsOutput {
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                             foo: ::std::option::Option::None,
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostUnionWithJsonNameOutput {
                             value: crate::model::UnionWithJsonName::Foo("".to_owned()),
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-26587
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-26597
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithNoBlobBody
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameRequest3
     #[::tokio::test]
     async fn rest_json_streaming_traits_with_no_blob_body_request() {
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_request3_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraits")
             .uri("/PostUnionWithJsonName")
             .method("POST")
             .header("X-Foo", "Foo")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"value\": {\n        \"bar\": \"hi\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits(move |input: crate::input::StreamingTraitsInput| {
             .post_union_with_json_name(move |input: crate::input::PostUnionWithJsonNameInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::StreamingTraitsInput {
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                         let expected = crate::input::PostUnionWithJsonNameInput {
                             value: ::std::option::Option::Some(
                                 crate::model::UnionWithJsonName::Bar("hi".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.blob.collect().await.unwrap().into_bytes(),
                             expected.blob.collect().await.unwrap().into_bytes()
                         );
                         let response = crate::output::StreamingTraitsOutput {
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                             foo: ::std::option::Option::None,
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::PostUnionWithJsonNameOutput {
                             value: crate::model::UnionWithJsonName::Foo("".to_owned()),
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-26635
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-26645
+    }
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithBlob
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse1
     #[::tokio::test]
     async fn rest_json_streaming_traits_with_blob_response() {
         let output = crate::output::StreamingTraitsOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b"blobby blob blob"),
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_response1_response() {
         let output = crate::output::PostUnionWithJsonNameOutput {
             value: crate::model::UnionWithJsonName::Foo("hi".to_owned()),
         };
         use ::aws_smithy_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 = [
             ("Content-Type", "application/octet-stream"),
             ("X-Foo", "Foo"),
         ];
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
             "{\n    \"value\": {\n        \"FOO\": \"hi\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-26673
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithNoBlobBody
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse2
     #[::tokio::test]
     async fn rest_json_streaming_traits_with_no_blob_body_response() {
         let output = crate::output::StreamingTraitsOutput {
             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
             foo: ::std::option::Option::Some("Foo".to_owned()),
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_response2_response() {
         let output = crate::output::PostUnionWithJsonNameOutput {
             value: crate::model::UnionWithJsonName::Baz("hi".to_owned()),
         };
         use ::aws_smithy_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-Foo", "Foo")];
         let expected_headers = [("Content-Type", "application/json")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_streaming_traits_require_length_test {
     /// Serializes a blob in the HTTP payload with a required length
     /// Test ID: RestJsonStreamingTraitsRequireLengthWithBlob
     #[::tokio::test]
     async fn rest_json_streaming_traits_require_length_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraitsRequireLength")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits_require_length(
                 move |input: crate::input::StreamingTraitsRequireLengthInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StreamingTraitsRequireLengthInput {
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(
                                     b"blobby blob blob",
                                 ),
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.foo,
                                 expected.foo,
                                 "Unexpected value for `foo`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.blob.collect().await.unwrap().into_bytes(),
                                 expected.blob.collect().await.unwrap().into_bytes()
                             );
                             let response = crate::output::StreamingTraitsRequireLengthOutput {};
                             response
                         };
                         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());
--
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsRequireLengthWithNoBlobBody
     #[::tokio::test]
     async fn rest_json_streaming_traits_require_length_with_no_blob_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraitsRequireLength")
             .method("POST")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits_require_length(
                 move |input: crate::input::StreamingTraitsRequireLengthInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StreamingTraitsRequireLengthInput {
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.foo,
                                 expected.foo,
                                 "Unexpected value for `foo`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.blob.collect().await.unwrap().into_bytes(),
                                 expected.blob.collect().await.unwrap().into_bytes()
                             );
                             let response = crate::output::StreamingTraitsRequireLengthOutput {};
                             response
                         };
                         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());
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_streaming_traits_with_media_type_test {
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     async fn rest_json_streaming_traits_with_media_type_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraitsWithMediaType")
             .method("POST")
             .header("Content-Type", "text/plain")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits_with_media_type(
                 move |input: crate::input::StreamingTraitsWithMediaTypeInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StreamingTraitsWithMediaTypeInput {
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(
                                     b"blobby blob blob",
                                 ),
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.foo,
                                 expected.foo,
                                 "Unexpected value for `foo`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.blob.collect().await.unwrap().into_bytes(),
                                 expected.blob.collect().await.unwrap().into_bytes()
                             );
                             let response = crate::output::StreamingTraitsWithMediaTypeOutput {
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                                 foo: ::std::option::Option::None,
                             };
                             response
                         };
                         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());
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{\n    \"value\": {\n        \"_baz\": \"hi\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-26701
+    }
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob
     /// Tests that jsonName works with union members.
     /// Test ID: PostUnionWithJsonNameResponse3
     #[::tokio::test]
     async fn rest_json_streaming_traits_with_media_type_with_blob_response() {
         let output = crate::output::StreamingTraitsWithMediaTypeOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b"blobby blob blob"),
     #[::tracing_test::traced_test]
     async fn post_union_with_json_name_response3_response() {
         let output = crate::output::PostUnionWithJsonNameOutput {
             value: crate::model::UnionWithJsonName::Bar("hi".to_owned()),
         };
         use ::aws_smithy_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 = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
             "{\n    \"value\": {\n        \"bar\": \"hi\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-26729
+    }
-26730
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_test_body_structure_test {
     /// Serializes a structure
     /// Test ID: RestJsonTestBodyStructure
     #[::tokio::test]
     async fn rest_json_test_body_structure_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/body")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\"testConfig\":\n    {\"timeout\": 10}\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_body_structure(move |input: crate::input::TestBodyStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestBodyStructureInput {
                             test_config: ::std::option::Option::Some(crate::model::TestConfig {
                                 timeout: ::std::option::Option::Some(10),
                             }),
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestBodyStructureOutput {
                             test_id: ::std::option::Option::None,
                             test_config: ::std::option::Option::None,
                         };
                         response
                     };
                     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());
-+
 const CONTENT_TYPE_POSTPLAYERACTION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PostPlayerActionInput`](crate::input::PostPlayerActionInput) using modelled bindings.
     pub struct PostPlayerActionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostPlayerActionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-26738
+    }
     /// Serializes an empty structure in the body
     /// Test ID: RestJsonHttpWithEmptyBody
     #[::tokio::test]
     async fn rest_json_http_with_empty_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/body")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_body_structure(move |input: crate::input::TestBodyStructureInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestBodyStructureInput {
                             test_id: ::std::option::Option::None,
                             test_config: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestBodyStructureOutput {
                             test_id: ::std::option::Option::None,
                             test_config: ::std::option::Option::None,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
--
+                }
             })
             .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
-+
+}
-+
 impl std::future::Future for PostPlayerActionInputFuture {
     type Output = Result<
         crate::input::PostPlayerActionInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostPlayerActionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostPlayerActionInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_POSTPLAYERACTION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_post_player_action::de_post_player_action_http_request(
                 request,
-+
+            )
             .await
             .expect("unable to make an HTTP request");
         assert!(receiver.recv().await.is_some());
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         PostPlayerActionInputFuture {
             inner: Box::pin(fut),
-+
+        }
-26798
+    }
-26799
+}
 #[cfg(test)]
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostPlayerActionOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_post_player_action::ser_post_player_action_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 mod server_test_no_payload_test {
     /// Serializes a GET request with no modeled body
     /// Test ID: RestJsonHttpWithNoModeledBody
 #[cfg(test)]
 mod post_player_action_test {
-+
     /// Unit types in unions are serialized like normal structures in requests.
     /// Test ID: RestJsonInputUnionWithUnitMember
     #[::tokio::test]
     async fn rest_json_http_with_no_modeled_body_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_input_union_with_unit_member_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/no_payload")
             .method("GET")
             .uri("/PostPlayerAction")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"action\": {\n        \"quit\": {}\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_no_payload(move |input: crate::input::TestNoPayloadInput| {
             .post_player_action(move |input: crate::input::PostPlayerActionInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestNoPayloadInput {
                             test_id: ::std::option::Option::None,
                         let expected = crate::input::PostPlayerActionInput {
                             action: ::std::option::Option::Some(crate::model::PlayerAction::Quit),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestNoPayloadOutput {
                             test_id: ::std::option::Option::None,
                         let response = crate::output::PostPlayerActionOutput {
                             action: crate::model::PlayerAction::Quit,
                         };
                         response
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-26857
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-26867
+    }
     /// Serializes a GET request with header member but no modeled body
     /// Test ID: RestJsonHttpWithHeaderMemberNoModeledBody
     /// Unit types in unions are serialized like normal structures in responses.
     /// Test ID: RestJsonOutputUnionWithUnitMember
     #[::tokio::test]
     async fn rest_json_http_with_header_member_no_modeled_body_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_output_union_with_unit_member_response() {
         let output = crate::output::PostPlayerActionOutput {
             action: crate::model::PlayerAction::Quit,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"action\": {\n        \"quit\": {}\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_JSONUNIONS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonUnionsInput`](crate::input::JsonUnionsInput) using modelled bindings.
     pub struct JsonUnionsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonUnionsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-+
+    }
-+
+}
-+
 impl std::future::Future for JsonUnionsInputFuture {
     type Output = Result<
         crate::input::JsonUnionsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonUnionsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-+
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonUnionsInputFuture;
-+
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         JsonUnionsInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonUnionsOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonUnionsError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_unions_test {
-+
     /// Serializes a string union value
     /// Test ID: RestJsonSerializeStringUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_string_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/no_payload")
             .method("GET")
             .header("X-Amz-Test-Id", "t-12345")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_no_payload(move |input: crate::input::TestNoPayloadInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestNoPayloadInput {
                             test_id: ::std::option::Option::Some("t-12345".to_owned()),
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::StringValue("foo".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestNoPayloadOutput {
                             test_id: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27041
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27051
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_test_payload_blob_test {
     /// Serializes a payload targeting an empty blob
     /// Test ID: RestJsonHttpWithEmptyBlobPayload
     /// Serializes a boolean union value
     /// Test ID: RestJsonSerializeBooleanUnionValue
     #[::tokio::test]
     async fn rest_json_http_with_empty_blob_payload_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_boolean_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/blob_payload")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_payload_blob(move |input: crate::input::TestPayloadBlobInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadBlobInput {
                             content_type: ::std::option::Option::Some(
                                 "application/octet-stream".to_owned(),
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::BooleanValue(true),
                             ),
                             data: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadBlobOutput {
                             content_type: ::std::option::Option::None,
                             data: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27089
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27099
+    }
     /// Serializes a payload targeting a blob
     /// Test ID: RestJsonTestPayloadBlob
     /// Serializes a number union value
     /// Test ID: RestJsonSerializeNumberUnionValue
     #[::tokio::test]
     async fn rest_json_test_payload_blob_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_number_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/blob_payload")
             .method("POST")
             .header("Content-Type", "image/jpg")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("1234".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_payload_blob(move |input: crate::input::TestPayloadBlobInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadBlobInput {
                             content_type: ::std::option::Option::Some("image/jpg".to_owned()),
                             data: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "1234",
                             )),
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::NumberValue(1),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadBlobOutput {
                             content_type: ::std::option::Option::None,
                             data: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27137
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27147
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_test_payload_structure_test {
     /// Serializes a payload targeting an empty structure
     /// Test ID: RestJsonHttpWithEmptyStructurePayload
     /// Serializes a blob union value
     /// Test ID: RestJsonSerializeBlobUnionValue
     #[::tokio::test]
     async fn rest_json_http_with_empty_structure_payload_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_blob_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/payload")
             .method("POST")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_payload_structure(move |input: crate::input::TestPayloadStructureInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadStructureInput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::BlobValue(::aws_smithy_types::Blob::new(
                                     "foo",
                                 )),
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadStructureOutput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27187
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27197
+    }
     /// Serializes a payload targeting a structure
     /// Test ID: RestJsonTestPayloadStructure
     /// Serializes a timestamp union value
     /// Test ID: RestJsonSerializeTimestampUnionValue
     #[::tokio::test]
     async fn rest_json_test_payload_structure_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_timestamp_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/payload")
             .method("POST")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\"data\": 25\n}".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_payload_structure(move |input: crate::input::TestPayloadStructureInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadStructureInput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::Some(25),
                                 },
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::TimestampValue(
                                     ::aws_smithy_types::DateTime::from_fractional_secs(
                                         1398796238, 0_f64,
                                     ),
                                 ),
                             ),
                             test_id: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadStructureOutput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27240
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27250
+    }
     /// Serializes an request with header members but no payload
     /// Test ID: RestJsonHttpWithHeadersButNoPayload
     /// Serializes an enum union value
     /// Test ID: RestJsonSerializeEnumUnionValue
     #[::tokio::test]
     async fn rest_json_http_with_headers_but_no_payload_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_enum_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/payload")
             .method("POST")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .header("X-Amz-Test-Id", "t-12345")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .test_payload_structure(move |input: crate::input::TestPayloadStructureInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TestPayloadStructureInput {
                             test_id: ::std::option::Option::Some("t-12345".to_owned()),
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::EnumValue(
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TestPayloadStructureOutput {
                             payload_config: ::std::option::Option::Some(
                                 crate::model::PayloadConfig {
                                     data: ::std::option::Option::None,
                                 },
                             ),
                             test_id: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27292
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27302
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_timestamp_format_headers_test {
     /// Tests how timestamp request headers are serialized
     /// Test ID: RestJsonTimestampFormatHeaders
     /// Serializes a list union value
     /// Test ID: RestJsonSerializeListUnionValue
     #[::tokio::test]
     async fn rest_json_timestamp_format_headers_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_list_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/TimestampFormatHeaders")
             .method("POST")
             .header("X-defaultFormat", "Mon, 16 Dec 2019 23:48:18 GMT")
             .header("X-memberDateTime", "2019-12-16T23:48:18Z")
             .header("X-memberEpochSeconds", "1576540098")
             .header("X-memberHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT")
             .header("X-targetDateTime", "2019-12-16T23:48:18Z")
             .header("X-targetEpochSeconds", "1576540098")
             .header("X-targetHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT")
             .uri("/JsonUnions")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
                 ::bytes::Bytes::from_static(
                     "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .timestamp_format_headers(move |input: crate::input::TimestampFormatHeadersInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TimestampFormatHeadersInput {
                             member_epoch_seconds: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             member_http_date: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             member_date_time: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             default_format: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             target_epoch_seconds: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             target_http_date: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             target_date_time: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::ListValue(vec![
                                     "foo".to_owned(),
                                     "bar".to_owned(),
                                 ]),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TimestampFormatHeadersOutput {
                             member_epoch_seconds: ::std::option::Option::None,
                             member_http_date: ::std::option::Option::None,
                             member_date_time: ::std::option::Option::None,
                             default_format: ::std::option::Option::None,
                             target_epoch_seconds: ::std::option::Option::None,
                             target_http_date: ::std::option::Option::None,
                             target_date_time: ::std::option::Option::None,
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         response
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27344
+                }
             })
             .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());
--
+    }
     /// Tests how timestamp response headers are serialized
     /// Test ID: RestJsonTimestampFormatHeaders
     #[::tokio::test]
     async fn rest_json_timestamp_format_headers_response() {
         let output = crate::output::TimestampFormatHeadersOutput {
             member_epoch_seconds: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             member_http_date: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             member_date_time: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             default_format: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             target_epoch_seconds: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             target_http_date: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             target_date_time: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
         };
         use ::aws_smithy_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-defaultFormat", "Mon, 16 Dec 2019 23:48:18 GMT"),
             ("X-memberDateTime", "2019-12-16T23:48:18Z"),
             ("X-memberEpochSeconds", "1576540098"),
             ("X-memberHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT"),
             ("X-targetDateTime", "2019-12-16T23:48:18Z"),
             ("X-targetEpochSeconds", "1576540098"),
             ("X-targetHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_unit_input_and_output_test {
     /// A unit type input serializes no payload. When clients do not
     /// need to serialize any data in the payload, they should omit
     /// a payload altogether.
     /// Test ID: RestJsonUnitInputAndOutput
         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"
         );
-+
+    }
     /// Serializes a map union value
     /// Test ID: RestJsonSerializeMapUnionValue
     #[::tokio::test]
     async fn rest_json_unit_input_and_output_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_map_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/UnitInputAndOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
                     let mut http_request = http::Request::builder()
                         .uri("/JsonUnions")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .unit_input_and_output(move |input: crate::input::UnitInputAndOutputInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::UnitInputAndOutputInput {};
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(crate::model::MyUnion::MapValue(
-+
+                                {
                                     let mut ret = ::std::collections::HashMap::new();
                                     ret.insert("foo".to_owned(), "bar".to_owned());
                                     ret.insert("spam".to_owned(), "eggs".to_owned());
                                     ret
                                 },
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::UnitInputAndOutputOutput {};
                         response
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27392
+                }
             })
             .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());
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
-27402
+    }
     /// Servers should allow the accept header to be set to the
     /// default content-type.
     /// Test ID: RestJsonUnitInputAllowsAccept
     /// Serializes a structure union value
     /// Test ID: RestJsonSerializeStructureUnionValue
     #[::tokio::test]
     async fn rest_json_unit_input_allows_accept_request() {
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_structure_union_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/UnitInputAndOutput")
             .method("POST")
             .header("Accept", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
                     let mut http_request = http::Request::builder()
                         .uri("/JsonUnions")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .unit_input_and_output(move |input: crate::input::UnitInputAndOutputInput| {
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::UnitInputAndOutputInput {};
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::StructureValue(
                                     crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("hello".to_owned()),
                                     },
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::UnitInputAndOutputOutput {};
                         response
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-27439
+                }
             })
             .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());
--
+    }
     /// When an operation defines Unit output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonUnitInputAndOutputNoOutput
     #[::tokio::test]
     async fn rest_json_unit_input_and_output_no_output_response() {
         let output = crate::output::UnitInputAndOutputOutput {};
         use ::aws_smithy_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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
--
+    }
--
+}
--
 const CONTENT_TYPE_PUTWITHCONTENTENCODING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput) using modelled bindings.
     pub struct PutWithContentEncodingInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PutWithContentEncodingInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for PutWithContentEncodingInputFuture {
     type Output = Result<
         crate::input::PutWithContentEncodingInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PutWithContentEncodingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PutWithContentEncodingInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PUTWITHCONTENTENCODING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         );
         PutWithContentEncodingInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PutWithContentEncodingOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_FRACTIONALSECONDS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`FractionalSecondsInput`](crate::input::FractionalSecondsInput) using modelled bindings.
     pub struct FractionalSecondsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::FractionalSecondsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for FractionalSecondsInputFuture {
     type Output = Result<
         crate::input::FractionalSecondsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FRACTIONALSECONDS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
--
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         );
         FractionalSecondsInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::FractionalSecondsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_DATETIMEOFFSETS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DatetimeOffsetsInput`](crate::input::DatetimeOffsetsInput) using modelled bindings.
     pub struct DatetimeOffsetsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DatetimeOffsetsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for DatetimeOffsetsInputFuture {
     type Output = Result<
         crate::input::DatetimeOffsetsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DatetimeOffsetsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DatetimeOffsetsInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DATETIMEOFFSETS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         );
         DatetimeOffsetsInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DatetimeOffsetsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_TESTNOPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestNoPayloadInput`](crate::input::TestNoPayloadInput) using modelled bindings.
     pub struct TestNoPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestNoPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for TestNoPayloadInputFuture {
     type Output = Result<
         crate::input::TestNoPayloadInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestNoPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestNoPayloadInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTNOPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_test_no_payload::de_test_no_payload_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         assert!(
             receiver.recv().await.is_some(),
             "we expected operation handler to be invoked but it was not entered"
         );
         TestNoPayloadInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestNoPayloadOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_no_payload::ser_test_no_payload_http_response(self)
--
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPayloadBlobInput`](crate::input::TestPayloadBlobInput) using modelled bindings.
     pub struct TestPayloadBlobInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadBlobInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for TestPayloadBlobInputFuture {
     type Output = Result<
         crate::input::TestPayloadBlobInput,
         ::aws_smithy_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)
-27449
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadBlobInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_test_payload_blob::de_test_payload_blob_http_request(
                 request,
--
+            )
     /// Serializes a renamed structure union value
     /// Test ID: RestJsonSerializeRenamedStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serialize_renamed_structure_union_value_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonUnions")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"contents\": {\n        \"renamedStructureValue\": {\n            \"salutation\": \"hello!\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_unions(move |input: crate::input::JsonUnionsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonUnionsInput {
                             contents: ::std::option::Option::Some(
                                 crate::model::MyUnion::RenamedStructureValue(
                                     crate::model::RenamedGreeting {
                                         salutation: ::std::option::Option::Some(
                                             "hello!".to_owned(),
                                         ),
                                     },
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonUnionsOutput {
                             contents: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-+
+                }
             })
             .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
             .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"
         );
         TestPayloadBlobInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadBlobOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_blob::ser_test_payload_blob_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_TESTPAYLOADSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestPayloadStructureInput`](crate::input::TestPayloadStructureInput) using modelled bindings.
     pub struct TestPayloadStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestPayloadStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for TestPayloadStructureInputFuture {
     type Output = Result<
         crate::input::TestPayloadStructureInput,
         ::aws_smithy_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)
-27498
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestPayloadStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestPayloadStructureInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTPAYLOADSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Deserializes a string union value
     /// Test ID: RestJsonDeserializeStringUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_string_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::StringValue(
                 "foo".to_owned(),
             )),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         TestPayloadStructureInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestPayloadStructureOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_payload_structure::ser_test_payload_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_TESTBODYSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TestBodyStructureInput`](crate::input::TestBodyStructureInput) using modelled bindings.
     pub struct TestBodyStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TestBodyStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for TestBodyStructureInputFuture {
     type Output = Result<
         crate::input::TestBodyStructureInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TestBodyStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TestBodyStructureInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TESTBODYSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_request(
                 request,
--
+            )
         let expected_headers = [("Content-Type", "application/json")];
         ::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
             .map_err(Into::into)
             .expect("unable to extract body to bytes");
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
             &body,
             "{\n    \"contents\": {\n        \"stringValue\": \"foo\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
     /// Deserializes a boolean union value
     /// Test ID: RestJsonDeserializeBooleanUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_boolean_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::BooleanValue(true)),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         TestBodyStructureInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TestBodyStructureOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 static CONTENT_TYPE_MALFORMEDACCEPTWITHGENERICSTRING: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithGenericStringInput`](crate::input::MalformedAcceptWithGenericStringInput) using modelled bindings.
     pub struct MalformedAcceptWithGenericStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithGenericStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedAcceptWithGenericStringInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithGenericStringInput,
         ::aws_smithy_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)
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"booleanValue\": true\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-27556
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithGenericStringInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHGENERICSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_accept_with_generic_string::de_malformed_accept_with_generic_string_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Deserializes a number union value
     /// Test ID: RestJsonDeserializeNumberUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_number_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::NumberValue(1)),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedAcceptWithGenericStringInputFuture {
             inner: Box::pin(fut),
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"numberValue\": 1\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-27584
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithGenericStringOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_generic_string::ser_malformed_accept_with_generic_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Deserializes a blob union value
     /// Test ID: RestJsonDeserializeBlobUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_blob_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::BlobValue(
                 ::aws_smithy_types::Blob::new("foo"),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"blobValue\": \"Zm9v\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-27614
+    }
--
+}
--
 static CONTENT_TYPE_MALFORMEDACCEPTWITHPAYLOAD: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "image/jpeg"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithPayloadInput`](crate::input::MalformedAcceptWithPayloadInput) using modelled bindings.
     pub struct MalformedAcceptWithPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// Deserializes a timestamp union value
     /// Test ID: RestJsonDeserializeTimestampUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_timestamp_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::TimestampValue(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"timestampValue\": 1398796238\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-27644
+    }
--
+}
--
 impl std::future::Future for MalformedAcceptWithPayloadInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithPayloadInput,
         ::aws_smithy_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)
     /// Deserializes an enum union value
     /// Test ID: RestJsonDeserializeEnumUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_enum_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::EnumValue(
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"enumValue\": \"Foo\"\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-27676
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithPayloadInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_accept_with_payload::de_malformed_accept_with_payload_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Deserializes a list union value
     /// Test ID: RestJsonDeserializeListUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_list_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::ListValue(vec![
                 "foo".to_owned(),
                 "bar".to_owned(),
             ])),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"contents\": {\n        \"listValue\": [\"foo\", \"bar\"]\n    }\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
     /// Deserializes a map union value
     /// Test ID: RestJsonDeserializeMapUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_map_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::MapValue({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), "bar".to_owned());
                 ret.insert("spam".to_owned(), "eggs".to_owned());
                 ret
             })),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"contents\": {\n        \"mapValue\": {\n            \"foo\": \"bar\",\n            \"spam\": \"eggs\"\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         MalformedAcceptWithPayloadInputFuture {
             inner: Box::pin(fut),
--
+        }
-27738
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithPayloadOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_payload::ser_malformed_accept_with_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Deserializes a structure union value
     /// Test ID: RestJsonDeserializeStructureUnionValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserialize_structure_union_value_response() {
         let output = crate::output::JsonUnionsOutput {
             contents: ::std::option::Option::Some(crate::model::MyUnion::StructureValue(
                 crate::model::GreetingStruct {
                     hi: ::std::option::Option::Some("hello".to_owned()),
                 },
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"contents\": {\n        \"structureValue\": {\n            \"hi\": \"hello\"\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-27768
+    }
-27769
+}
-27770
 const CONTENT_TYPE_MALFORMEDACCEPTWITHBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_DOCUMENTTYPEASMAPVALUE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedAcceptWithBodyInput`](crate::input::MalformedAcceptWithBodyInput) using modelled bindings.
     pub struct MalformedAcceptWithBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedAcceptWithBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`DocumentTypeAsMapValueInput`](crate::input::DocumentTypeAsMapValueInput) using modelled bindings.
     pub struct DocumentTypeAsMapValueInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsMapValueInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-27777
+    }
-27778
+}
-27779
 impl std::future::Future for MalformedAcceptWithBodyInputFuture {
 impl std::future::Future for DocumentTypeAsMapValueInputFuture {
     type Output = Result<
         crate::input::MalformedAcceptWithBodyInput,
         crate::input::DocumentTypeAsMapValueInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-27785
     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)
-27792
+    }
-27793
+}
-27794
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedAcceptWithBodyInput
     > for crate::input::DocumentTypeAsMapValueInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-27803
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-27807
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedAcceptWithBodyInputFuture;
     type Future = DocumentTypeAsMapValueInputFuture;
-27810
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDACCEPTWITHBODY,
                 &CONTENT_TYPE_DOCUMENTTYPEASMAPVALUE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-27818
+            }
             crate::protocol_serde::shape_malformed_accept_with_body::de_malformed_accept_with_body_http_request(request)
             crate::protocol_serde::shape_document_type_as_map_value::de_document_type_as_map_value_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-27829
+                )
             },
         );
         MalformedAcceptWithBodyInputFuture {
         DocumentTypeAsMapValueInputFuture {
             inner: Box::pin(fut),
-27834
+        }
-27835
+    }
-27836
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedAcceptWithBodyOutput
     > for crate::output::DocumentTypeAsMapValueOutput
-27841
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_accept_with_body::ser_malformed_accept_with_body_http_response(self) {
         match crate::protocol_serde::shape_document_type_as_map_value::ser_document_type_as_map_value_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-27848
+                        }
-27849
+                    }
-27850
+    }
-27851
+}
-27852
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHGENERICSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithGenericStringInput`](crate::input::MalformedContentTypeWithGenericStringInput) using modelled bindings.
     pub struct MalformedContentTypeWithGenericStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithGenericStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedContentTypeWithGenericStringInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithGenericStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod document_type_as_map_value_test {
-27856
     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)
     /// Serializes a map that uses documents as the value.
     /// Test ID: DocumentTypeAsMapValueInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_map_value_input_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/DocumentTypeAsMapValue")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"docValuedMap\": {\n        \"foo\": { \"f\": 1, \"o\": 2 },\n        \"bar\": [ \"b\", \"a\", \"r\" ],\n        \"baz\": \"BAZ\"\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type_as_map_value(move |input: crate::input::DocumentTypeAsMapValueInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeAsMapValueInput {
                             doc_valued_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("foo".to_owned(), {
                                     let json_bytes = br#"{
                                         "f": 1,
                                         "o": 2
                                     }"#;
                                     let mut tokens =
                                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                             .peekable();
                                     ::aws_smithy_json::deserialize::token::expect_document(
                                         &mut tokens,
-+
+                                    )
                                     .expect("well formed json")
                                 });
                                 ret.insert("bar".to_owned(), {
                                     let json_bytes = br#"[
                                         "b",
                                         "a",
                                         "r"
                                     ]"#;
                                     let mut tokens =
                                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                             .peekable();
                                     ::aws_smithy_json::deserialize::token::expect_document(
                                         &mut tokens,
-+
+                                    )
                                     .expect("well formed json")
                                 });
                                 ret.insert("baz".to_owned(), {
                                     let json_bytes = br#""BAZ""#;
                                     let mut tokens =
                                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                             .peekable();
                                     ::aws_smithy_json::deserialize::token::expect_document(
                                         &mut tokens,
-+
+                                    )
                                     .expect("well formed json")
                                 });
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeAsMapValueOutput {
                             doc_valued_map: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-27937
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithGenericStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithGenericStringInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHGENERICSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_content_type_with_generic_string::de_malformed_content_type_with_generic_string_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Serializes a map that uses documents as the value.
     /// Test ID: DocumentTypeAsMapValueOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_map_value_output_response() {
         let output = crate::output::DocumentTypeAsMapValueOutput {
             doc_valued_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("foo".to_owned(), {
                     let json_bytes = br#"{
                                     "f": 1,
                                     "o": 2
                                 }"#;
                     let mut tokens =
                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                     ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                         .expect("well formed json")
                 });
                 ret.insert("bar".to_owned(), {
                     let json_bytes = br#"[
                                     "b",
                                     "a",
                                     "r"
                                 ]"#;
                     let mut tokens =
                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                     ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                         .expect("well formed json")
                 });
                 ret.insert("baz".to_owned(), {
                     let json_bytes = br#""BAZ""#;
                     let mut tokens =
                         ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                     ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                         .expect("well formed json")
                 });
                 ret
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"docValuedMap\": {\n        \"foo\": { \"f\": 1, \"o\": 2 },\n        \"bar\": [ \"b\", \"a\", \"r\" ],\n        \"baz\": \"BAZ\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         MalformedContentTypeWithGenericStringInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithGenericStringOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_generic_string::ser_malformed_content_type_with_generic_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
-27994
+    }
-27995
+}
-27996
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_DOCUMENTTYPEASPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithPayloadInput`](crate::input::MalformedContentTypeWithPayloadInput) using modelled bindings.
     pub struct MalformedContentTypeWithPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`DocumentTypeAsPayloadInput`](crate::input::DocumentTypeAsPayloadInput) using modelled bindings.
     pub struct DocumentTypeAsPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-28003
+    }
-28004
+}
-28005
 impl std::future::Future for MalformedContentTypeWithPayloadInputFuture {
 impl std::future::Future for DocumentTypeAsPayloadInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithPayloadInput,
         crate::input::DocumentTypeAsPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-28011
     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)
-28018
+    }
-28019
+}
-28020
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithPayloadInput
     > for crate::input::DocumentTypeAsPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28029
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28033
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithPayloadInputFuture;
     type Future = DocumentTypeAsPayloadInputFuture;
-28036
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHPAYLOAD,
                 &CONTENT_TYPE_DOCUMENTTYPEASPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28044
+            }
             crate::protocol_serde::shape_malformed_content_type_with_payload::de_malformed_content_type_with_payload_http_request(request)
             crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28055
+                )
             },
         );
         MalformedContentTypeWithPayloadInputFuture {
         DocumentTypeAsPayloadInputFuture {
             inner: Box::pin(fut),
-28060
+        }
-28061
+    }
-28062
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithPayloadOutput
     > for crate::output::DocumentTypeAsPayloadOutput
-28067
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_payload::ser_malformed_content_type_with_payload_http_response(self) {
         match crate::protocol_serde::shape_document_type_as_payload::ser_document_type_as_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28074
+                        }
-28075
+                    }
-28076
+    }
-28077
+}
-28078
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithBodyInput`](crate::input::MalformedContentTypeWithBodyInput) using modelled bindings.
     pub struct MalformedContentTypeWithBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedContentTypeWithBodyInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithBodyInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod document_type_as_payload_test {
-28082
     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)
     /// Serializes a document as the target of the httpPayload trait.
     /// Test ID: DocumentTypeAsPayloadInput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_payload_input_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentTypeAsPayload")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"foo\": \"bar\"\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type_as_payload(move |input: crate::input::DocumentTypeAsPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeAsPayloadInput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"{
                                 "foo": "bar"
                             }"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeAsPayloadOutput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
-28142
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithBodyInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_content_type_with_body::de_malformed_content_type_with_body_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Serializes a document as the target of the httpPayload trait using a string.
     /// Test ID: DocumentTypeAsPayloadInputString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_payload_input_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentTypeAsPayload")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("\"hello\"".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type_as_payload(move |input: crate::input::DocumentTypeAsPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeAsPayloadInput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#""hello""#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeAsPayloadOutput {
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes a document as the target of the httpPayload trait.
     /// Test ID: DocumentTypeAsPayloadOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_payload_output_response() {
         let output = crate::output::DocumentTypeAsPayloadOutput {
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"{
                             "foo": "bar"
                         }"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedContentTypeWithBodyInputFuture {
             inner: Box::pin(fut),
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"foo\": \"bar\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-28236
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithBodyOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_with_body::ser_malformed_content_type_with_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Serializes a document as a payload string.
     /// Test ID: DocumentTypeAsPayloadOutputString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_as_payload_output_string_response() {
         let output = crate::output::DocumentTypeAsPayloadOutput {
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#""hello""#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "\"hello\"",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-28270
+    }
-28271
+}
-28272
 const CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHOUTBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_DOCUMENTTYPE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedContentTypeWithoutBodyInput`](crate::input::MalformedContentTypeWithoutBodyInput) using modelled bindings.
     pub struct MalformedContentTypeWithoutBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedContentTypeWithoutBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`DocumentTypeInput`](crate::input::DocumentTypeInput) using modelled bindings.
     pub struct DocumentTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-28279
+    }
-28280
+}
-28281
 impl std::future::Future for MalformedContentTypeWithoutBodyInputFuture {
 impl std::future::Future for DocumentTypeInputFuture {
     type Output = Result<
         crate::input::MalformedContentTypeWithoutBodyInput,
         crate::input::DocumentTypeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-28287
     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)
-28294
+    }
-28295
+}
-28296
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedContentTypeWithoutBodyInput
     > for crate::input::DocumentTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28305
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28309
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedContentTypeWithoutBodyInputFuture;
     type Future = DocumentTypeInputFuture;
-28312
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHOUTBODY,
                 &CONTENT_TYPE_DOCUMENTTYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28320
+            }
             crate::protocol_serde::shape_malformed_content_type_without_body::de_malformed_content_type_without_body_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_document_type::de_document_type_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28331
+                )
             },
         );
         MalformedContentTypeWithoutBodyInputFuture {
         DocumentTypeInputFuture {
             inner: Box::pin(fut),
-28336
+        }
-28337
+    }
-28338
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedContentTypeWithoutBodyOutput
     > for crate::output::DocumentTypeOutput
-28343
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_content_type_without_body::ser_malformed_content_type_without_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDTIMESTAMPBODYHTTPDATE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyHttpDateInput`](crate::input::MalformedTimestampBodyHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampBodyHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         match crate::protocol_serde::shape_document_type::ser_document_type_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-28352
+    }
-28353
+}
-28354
 impl std::future::Future for MalformedTimestampBodyHttpDateInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyHttpDateInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod document_type_test {
-28358
     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)
     /// Serializes document types as part of the JSON request payload with no escaping.
     /// Test ID: DocumentTypeInputWithObject
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_type_input_with_object_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/DocumentType")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"{
                                 "foo": "bar"
                             }"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
-28417
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyHttpDateInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyHttpDateInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYHTTPDATE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_http_date::de_malformed_timestamp_body_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Serializes document types using a string.
     /// Test ID: DocumentInputWithString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_input_with_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentType")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#""hello""#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
         MalformedTimestampBodyHttpDateInputFuture {
             inner: Box::pin(fut),
--
+        }
-28480
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyHttpDateOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Serializes document types using a number.
     /// Test ID: DocumentInputWithNumber
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_input_with_number_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentType")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"10"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
-28542
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyHttpDateError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Serializes document types using a boolean.
     /// Test ID: DocumentInputWithBoolean
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_input_with_boolean_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/DocumentType")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"stringValue\": \"string\",\n    \"documentValue\": true\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"true"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes document types using a list.
     /// Test ID: DocumentInputWithList
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_input_with_list_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/DocumentType")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringValue\": \"string\",\n    \"documentValue\": [\n        true,\n        \"hi\",\n        [\n            1,\n            2\n        ],\n        {\n            \"foo\": {\n                \"baz\": [\n                    3,\n                    4\n                ]\n            }\n        }\n    ]\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .document_type(move |input: crate::input::DocumentTypeInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::DocumentTypeInput {
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"[
                                 true,
                                 "hi",
-+
+                                [
 ,
-+
                                 ],
-+
+                                {
                                     "foo": {
                                         "baz": [
 ,
-+
-+
+                                        ]
-+
+                                    }
-+
+                                }
                             ]"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::DocumentTypeOutput {
                             string_value: ::std::option::Option::None,
                             document_value: ::std::option::Option::Some({
                                 let json_bytes = br#"null"#;
                                 let mut tokens =
                                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes)
                                         .peekable();
                                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                                     .expect("well formed json")
                             }),
                         };
                         response
                     };
                     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"
         );
-28677
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDATETIME: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyDateTimeInput`](crate::input::MalformedTimestampBodyDateTimeInput) using modelled bindings.
     pub struct MalformedTimestampBodyDateTimeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDateTimeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// Serializes documents as part of the JSON response payload with no escaping.
     /// Test ID: DocumentOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_output_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"{
                             "foo": "bar"
                         }"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"stringValue\": \"string\",\n    \"documentValue\": {\n        \"foo\": \"bar\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-28712
+    }
--
+}
--
 impl std::future::Future for MalformedTimestampBodyDateTimeInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyDateTimeInput,
         ::aws_smithy_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)
     /// Document types can be JSON scalars too.
     /// Test ID: DocumentOutputString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_output_string_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#""hello""#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringValue\": \"string\",\n    \"documentValue\": \"hello\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-28747
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDateTimeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDateTimeInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDATETIME,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_date_time::de_malformed_timestamp_body_date_time_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Document types can be JSON scalars too.
     /// Test ID: DocumentOutputNumber
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_output_number_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"10"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedTimestampBodyDateTimeInputFuture {
             inner: Box::pin(fut),
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringValue\": \"string\",\n    \"documentValue\": 10\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-28782
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDateTimeOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Document types can be JSON scalars too.
     /// Test ID: DocumentOutputBoolean
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_output_boolean_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"false"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringValue\": \"string\",\n    \"documentValue\": false\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-28817
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyDateTimeError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Document types can be JSON arrays.
     /// Test ID: DocumentOutputArray
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn document_output_array_response() {
         let output = crate::output::DocumentTypeOutput {
             string_value: ::std::option::Option::Some("string".to_owned()),
             document_value: ::std::option::Option::Some({
                 let json_bytes = br#"[
                             true,
                             false
                         ]"#;
                 let mut tokens =
                     ::aws_smithy_json::deserialize::json_token_iter(json_bytes).peekable();
                 ::aws_smithy_json::deserialize::token::expect_document(&mut tokens)
                     .expect("well formed json")
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"stringValue\": \"string\",\n    \"documentValue\": [\n        true,\n        false\n    ]\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-28853
+    }
-28854
+}
-28855
 const CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_JSONBLOBS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampBodyDefaultInput`](crate::input::MalformedTimestampBodyDefaultInput) using modelled bindings.
     pub struct MalformedTimestampBodyDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampBodyDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`JsonBlobsInput`](crate::input::JsonBlobsInput) using modelled bindings.
     pub struct JsonBlobsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonBlobsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-28862
+    }
-28863
+}
-28864
 impl std::future::Future for MalformedTimestampBodyDefaultInputFuture {
 impl std::future::Future for JsonBlobsInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampBodyDefaultInput,
         crate::input::JsonBlobsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-28870
     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)
-28877
+    }
-28878
+}
-28879
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampBodyDefaultInput
     > for crate::input::JsonBlobsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-28888
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-28892
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampBodyDefaultInputFuture;
     type Future = JsonBlobsInputFuture;
-28895
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDEFAULT,
                 &CONTENT_TYPE_JSONBLOBS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-28903
+            }
             crate::protocol_serde::shape_malformed_timestamp_body_default::de_malformed_timestamp_body_default_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_json_blobs::de_json_blobs_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-28914
+                )
             },
         );
         MalformedTimestampBodyDefaultInputFuture {
         JsonBlobsInputFuture {
             inner: Box::pin(fut),
-28919
+        }
-28920
+    }
-28921
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampBodyDefaultOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampBodyDefaultError
     > for crate::output::JsonBlobsOutput
-28926
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
         match crate::protocol_serde::shape_json_blobs::ser_json_blobs_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-28933
+            }
-28934
+        }
-28935
+    }
-28936
+}
-28937
 const CONTENT_TYPE_MALFORMEDTIMESTAMPHEADEREPOCH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderEpochInput`](crate::input::MalformedTimestampHeaderEpochInput) using modelled bindings.
     pub struct MalformedTimestampHeaderEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedTimestampHeaderEpochInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderEpochInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_blobs_test {
-28941
     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)
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_blobs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonBlobs")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"data\": \"dmFsdWU=\"\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_blobs(move |input: crate::input::JsonBlobsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonBlobsInput {
                             data: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "value",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonBlobsOutput {
                             data: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-28987
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderEpochInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderEpochInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADEREPOCH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_epoch::de_malformed_timestamp_header_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Blobs are base64 encoded
     /// Test ID: RestJsonJsonBlobs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_blobs_response() {
         let output = crate::output::JsonBlobsOutput {
             data: ::std::option::Option::Some(::aws_smithy_types::Blob::new("value")),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedTimestampHeaderEpochInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderEpochOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderEpochError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"data\": \"dmFsdWU=\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-29015
+    }
-29016
+}
-29017
 const CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDATETIME: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_SPARSEJSONMAPS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderDateTimeInput`](crate::input::MalformedTimestampHeaderDateTimeInput) using modelled bindings.
     pub struct MalformedTimestampHeaderDateTimeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDateTimeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`SparseJsonMapsInput`](crate::input::SparseJsonMapsInput) using modelled bindings.
     pub struct SparseJsonMapsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonMapsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-29024
+    }
-29025
+}
-29026
 impl std::future::Future for MalformedTimestampHeaderDateTimeInputFuture {
 impl std::future::Future for SparseJsonMapsInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderDateTimeInput,
         crate::input::SparseJsonMapsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-29032
     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)
-29039
+    }
-29040
+}
-29041
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDateTimeInput
     > for crate::input::SparseJsonMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-29050
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-29054
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDateTimeInputFuture;
     type Future = SparseJsonMapsInputFuture;
-29057
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDATETIME,
                 &CONTENT_TYPE_SPARSEJSONMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-29065
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_date_time::de_malformed_timestamp_header_date_time_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_sparse_json_maps::de_sparse_json_maps_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-29076
+                )
             },
         );
         MalformedTimestampHeaderDateTimeInputFuture {
         SparseJsonMapsInputFuture {
             inner: Box::pin(fut),
-29081
+        }
-29082
+    }
-29083
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDateTimeOutput
     > for crate::output::SparseJsonMapsOutput
-29088
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-29099
+    }
-29100
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderDateTimeError
     > for crate::error::SparseJsonMapsError
-29105
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_error(&self) {
         match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_error(&self)
-+
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-29118
+            }
-29119
+        }
-29120
+    }
-29121
+}
-29122
 const CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod sparse_json_maps_test {
-+
     /// Serializes JSON maps
     /// Test ID: RestJsonSparseJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_sparse_json_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_struct_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "foo".to_owned(),
                                     ::std::option::Option::Some(crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("there".to_owned()),
                                     }),
                                 );
                                 ret.insert(
                                     "baz".to_owned(),
                                     ::std::option::Option::Some(crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("bye".to_owned()),
                                     }),
                                 );
                                 ret
                             }),
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// Serializes JSON map values in sparse maps
     /// Test ID: RestJsonSerializesSparseNullMapValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_sparse_null_map_values_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseBooleanMap\": {\n        \"x\": null\n    },\n    \"sparseNumberMap\": {\n        \"x\": null\n    },\n    \"sparseStringMap\": {\n        \"x\": null\n    },\n    \"sparseStructMap\": {\n        \"x\": null\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_boolean_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_number_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_string_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInSparseMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_zero_values_in_sparse_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseNumberMap\": {\n        \"x\": 0\n    },\n    \"sparseBooleanMap\": {\n        \"x\": false\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_number_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::Some(0));
                                 ret
                             }),
                             sparse_boolean_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), ::std::option::Option::Some(false));
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// A request that contains a sparse map of sets
     /// Test ID: RestJsonSerializesSparseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_sparse_set_map_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_set_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "x".to_owned(),
                                     ::std::option::Option::Some(
                                         vec![].try_into().expect("this is only used in tests"),
                                     ),
                                 );
                                 ret.insert(
                                     "y".to_owned(),
                                     ::std::option::Option::Some(
                                         vec!["a".to_owned(), "b".to_owned()]
                                             .try_into()
                                             .expect("this is only used in tests"),
                                     ),
                                 );
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// A request that contains a sparse map of sets.
     /// Test ID: RestJsonSerializesSparseSetMapAndRetainsNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_sparse_set_map_and_retains_null_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SparseJsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_maps(move |input: crate::input::SparseJsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonMapsInput {
                             sparse_set_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "x".to_owned(),
                                     ::std::option::Option::Some(
                                         vec![].try_into().expect("this is only used in tests"),
                                     ),
                                 );
                                 ret.insert(
                                     "y".to_owned(),
                                     ::std::option::Option::Some(
                                         vec!["a".to_owned(), "b".to_owned()]
                                             .try_into()
                                             .expect("this is only used in tests"),
                                     ),
                                 );
                                 ret.insert("z".to_owned(), ::std::option::Option::None);
                                 ret
                             }),
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonMapsOutput {
                             sparse_struct_map: ::std::option::Option::None,
                             sparse_number_map: ::std::option::Option::None,
                             sparse_boolean_map: ::std::option::Option::None,
                             sparse_string_map: ::std::option::Option::None,
                             sparse_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// Deserializes JSON maps
     /// Test ID: RestJsonSparseJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_sparse_json_maps_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_struct_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     ::std::option::Option::Some(crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("there".to_owned()),
                     }),
                 );
                 ret.insert(
                     "baz".to_owned(),
                     ::std::option::Option::Some(crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("bye".to_owned()),
                     }),
                 );
                 ret
             }),
             sparse_number_map: ::std::option::Option::None,
             sparse_boolean_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
             sparse_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n   }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
     /// Deserializes null JSON map values
     /// Test ID: RestJsonDeserializesSparseNullMapValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_sparse_null_map_values_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_boolean_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_number_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_string_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_struct_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseBooleanMap\": {\n        \"x\": null\n    },\n    \"sparseNumberMap\": {\n        \"x\": null\n    },\n    \"sparseStringMap\": {\n        \"x\": null\n    },\n    \"sparseStructMap\": {\n        \"x\": null\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonDeserializesZeroValuesInSparseMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_zero_values_in_sparse_maps_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_number_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(0));
                 ret
             }),
             sparse_boolean_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), ::std::option::Option::Some(false));
                 ret
             }),
             sparse_struct_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
             sparse_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseNumberMap\": {\n        \"x\": 0\n    },\n    \"sparseBooleanMap\": {\n        \"x\": false\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
     /// A response that contains a sparse map of sets
     /// Test ID: RestJsonDeserializesSparseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_sparse_set_map_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_set_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "x".to_owned(),
                     ::std::option::Option::Some(
                         vec![].try_into().expect("this is only used in tests"),
                     ),
                 );
                 ret.insert(
                     "y".to_owned(),
                     ::std::option::Option::Some(
                         vec!["a".to_owned(), "b".to_owned()]
                             .try_into()
                             .expect("this is only used in tests"),
                     ),
                 );
                 ret
             }),
             sparse_struct_map: ::std::option::Option::None,
             sparse_number_map: ::std::option::Option::None,
             sparse_boolean_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
     /// A response that contains a sparse map of sets.
     /// Test ID: RestJsonDeserializesSparseSetMapAndRetainsNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_sparse_set_map_and_retains_null_response() {
         let output = crate::output::SparseJsonMapsOutput {
             sparse_set_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "x".to_owned(),
                     ::std::option::Option::Some(
                         vec![].try_into().expect("this is only used in tests"),
                     ),
                 );
                 ret.insert(
                     "y".to_owned(),
                     ::std::option::Option::Some(
                         vec!["a".to_owned(), "b".to_owned()]
                             .try_into()
                             .expect("this is only used in tests"),
                     ),
                 );
                 ret.insert("z".to_owned(), ::std::option::Option::None);
                 ret
             }),
             sparse_struct_map: ::std::option::Option::None,
             sparse_number_map: ::std::option::Option::None,
             sparse_boolean_map: ::std::option::Option::None,
             sparse_string_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"sparseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"],\n        \"z\": null\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_JSONMAPS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampHeaderDefaultInput`](crate::input::MalformedTimestampHeaderDefaultInput) using modelled bindings.
     pub struct MalformedTimestampHeaderDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampHeaderDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`JsonMapsInput`](crate::input::JsonMapsInput) using modelled bindings.
     pub struct JsonMapsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonMapsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-29678
+    }
-29679
+}
-29680
 impl std::future::Future for MalformedTimestampHeaderDefaultInputFuture {
 impl std::future::Future for JsonMapsInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampHeaderDefaultInput,
         crate::input::JsonMapsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-29686
     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)
-29693
+    }
-29694
+}
-29695
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampHeaderDefaultInput
     > for crate::input::JsonMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-29704
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-29708
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampHeaderDefaultInputFuture;
     type Future = JsonMapsInputFuture;
-29711
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDEFAULT,
                 &CONTENT_TYPE_JSONMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-29719
+            }
             crate::protocol_serde::shape_malformed_timestamp_header_default::de_malformed_timestamp_header_default_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_json_maps::de_json_maps_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-29730
+                )
             },
         );
         MalformedTimestampHeaderDefaultInputFuture {
         JsonMapsInputFuture {
             inner: Box::pin(fut),
-29735
+        }
-29736
+    }
-29737
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampHeaderDefaultOutput
     > for crate::output::JsonMapsOutput
-29742
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_json_maps::ser_json_maps_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-29751
+    }
-29752
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampHeaderDefaultError
     > for crate::error::JsonMapsError
-29757
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_error(&self) {
         match crate::protocol_serde::shape_json_maps::ser_json_maps_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-29769
+            }
-29770
+        }
-29771
+    }
-29772
+}
-29773
 const CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYEPOCH: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_maps_test {
-+
     /// Serializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_maps(move |input: crate::input::JsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonMapsInput {
                             dense_struct_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "foo".to_owned(),
                                     crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("there".to_owned()),
                                     },
                                 );
                                 ret.insert(
                                     "baz".to_owned(),
                                     crate::model::GreetingStruct {
                                         hi: ::std::option::Option::Some("bye".to_owned()),
                                     },
                                 );
                                 ret
                             }),
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonMapsOutput {
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonSerializesZeroValuesInMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_zero_values_in_maps_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_maps(move |input: crate::input::JsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonMapsInput {
                             dense_number_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), 0);
                                 ret
                             }),
                             dense_boolean_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("x".to_owned(), false);
                                 ret
                             }),
                             dense_struct_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonMapsOutput {
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// A request that contains a dense map of sets.
     /// Test ID: RestJsonSerializesDenseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_dense_set_map_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonMaps")
                         .method("POST")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_maps(move |input: crate::input::JsonMapsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonMapsInput {
                             dense_set_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "x".to_owned(),
                                     vec![].try_into().expect("this is only used in tests"),
                                 );
                                 ret.insert(
                                     "y".to_owned(),
                                     vec!["a".to_owned(), "b".to_owned()]
                                         .try_into()
                                         .expect("this is only used in tests"),
                                 );
                                 ret
                             }),
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonMapsOutput {
                             dense_struct_map: ::std::option::Option::None,
                             dense_number_map: ::std::option::Option::None,
                             dense_boolean_map: ::std::option::Option::None,
                             dense_string_map: ::std::option::Option::None,
                             dense_set_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// Deserializes JSON maps
     /// Test ID: RestJsonJsonMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_maps_response() {
         let output = crate::output::JsonMapsOutput {
             dense_struct_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "foo".to_owned(),
                     crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("there".to_owned()),
                     },
                 );
                 ret.insert(
                     "baz".to_owned(),
                     crate::model::GreetingStruct {
                         hi: ::std::option::Option::Some("bye".to_owned()),
                     },
                 );
                 ret
             }),
             dense_number_map: ::std::option::Option::None,
             dense_boolean_map: ::std::option::Option::None,
             dense_string_map: ::std::option::Option::None,
             dense_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"denseStructMap\": {\n        \"foo\": {\n            \"hi\": \"there\"\n        },\n        \"baz\": {\n            \"hi\": \"bye\"\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
     /// Ensure that 0 and false are sent over the wire in all maps and lists
     /// Test ID: RestJsonDeserializesZeroValuesInMaps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_zero_values_in_maps_response() {
         let output = crate::output::JsonMapsOutput {
             dense_number_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), 0);
                 ret
             }),
             dense_boolean_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("x".to_owned(), false);
                 ret
             }),
             dense_struct_map: ::std::option::Option::None,
             dense_string_map: ::std::option::Option::None,
             dense_set_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"denseNumberMap\": {\n        \"x\": 0\n    },\n    \"denseBooleanMap\": {\n        \"x\": false\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
     /// A response that contains a dense map of sets.
     /// Test ID: RestJsonDeserializesDenseSetMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_deserializes_dense_set_map_response() {
         let output = crate::output::JsonMapsOutput {
             dense_set_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "x".to_owned(),
                     vec![].try_into().expect("this is only used in tests"),
                 );
                 ret.insert(
                     "y".to_owned(),
                     vec!["a".to_owned(), "b".to_owned()]
                         .try_into()
                         .expect("this is only used in tests"),
                 );
                 ret
             }),
             dense_struct_map: ::std::option::Option::None,
             dense_number_map: ::std::option::Option::None,
             dense_boolean_map: ::std::option::Option::None,
             dense_string_map: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"denseSetMap\": {\n        \"x\": [],\n        \"y\": [\"a\", \"b\"]\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_SPARSEJSONLISTS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryEpochInput`](crate::input::MalformedTimestampQueryEpochInput) using modelled bindings.
     pub struct MalformedTimestampQueryEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`SparseJsonListsInput`](crate::input::SparseJsonListsInput) using modelled bindings.
     pub struct SparseJsonListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-30095
+    }
-30096
+}
-30097
 impl std::future::Future for MalformedTimestampQueryEpochInputFuture {
 impl std::future::Future for SparseJsonListsInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryEpochInput,
         crate::input::SparseJsonListsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-30103
     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)
-30110
+    }
-30111
+}
-30112
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryEpochInput
     > for crate::input::SparseJsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30121
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30125
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryEpochInputFuture;
     type Future = SparseJsonListsInputFuture;
-30128
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYEPOCH,
                 &CONTENT_TYPE_SPARSEJSONLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30136
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_epoch::de_malformed_timestamp_query_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_sparse_json_lists::de_sparse_json_lists_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30149
+                )
             },
         );
         MalformedTimestampQueryEpochInputFuture {
         SparseJsonListsInputFuture {
             inner: Box::pin(fut),
-30154
+        }
-30155
+    }
-30156
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryEpochOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryEpochError
     > for crate::output::SparseJsonListsOutput
-30161
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
         match crate::protocol_serde::shape_sparse_json_lists::ser_sparse_json_lists_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30170
+            }
-30171
+        }
-30172
+    }
-30173
+}
-30174
 const CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYHTTPDATE: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod sparse_json_lists_test {
-+
     /// Serializes null values in sparse lists
     /// Test ID: RestJsonSparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_sparse_lists_serialize_null_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SparseJsonLists")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"sparseStringList\": [\n        null,\n        \"hi\"\n    ]\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .sparse_json_lists(move |input: crate::input::SparseJsonListsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::SparseJsonListsInput {
                             sparse_string_list: ::std::option::Option::Some(vec![
                                 ::std::option::Option::None,
                                 ::std::option::Option::Some("hi".to_owned()),
                             ]),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::SparseJsonListsOutput {
                             sparse_string_list: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes null values in sparse lists
     /// Test ID: RestJsonSparseListsSerializeNull
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_sparse_lists_serialize_null_response() {
         let output = crate::output::SparseJsonListsOutput {
             sparse_string_list: ::std::option::Option::Some(vec![
                 ::std::option::Option::None,
                 ::std::option::Option::Some("hi".to_owned()),
             ]),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"sparseStringList\": [\n        null,\n        \"hi\"\n    ]\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_JSONLISTS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryHttpDateInput`](crate::input::MalformedTimestampQueryHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampQueryHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`JsonListsInput`](crate::input::JsonListsInput) using modelled bindings.
     pub struct JsonListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-30268
+    }
-30269
+}
-30270
 impl std::future::Future for MalformedTimestampQueryHttpDateInputFuture {
 impl std::future::Future for JsonListsInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryHttpDateInput,
         crate::input::JsonListsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-30276
     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)
-30283
+    }
-30284
+}
-30285
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryHttpDateInput
     > for crate::input::JsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30294
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30298
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryHttpDateInputFuture;
     type Future = JsonListsInputFuture;
-30301
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYHTTPDATE,
                 &CONTENT_TYPE_JSONLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30309
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_http_date::de_malformed_timestamp_query_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_json_lists::de_json_lists_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30320
+                )
             },
         );
         MalformedTimestampQueryHttpDateInputFuture {
         JsonListsInputFuture {
             inner: Box::pin(fut),
-30325
+        }
-30326
+    }
-30327
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryHttpDateOutput
     > for crate::output::JsonListsOutput
-30332
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_json_lists::ser_json_lists_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-30341
+    }
-30342
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryHttpDateError
     > for crate::error::JsonListsError
-30347
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_error(&self) {
         match crate::protocol_serde::shape_json_lists::ser_json_lists_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30359
+            }
-30360
+        }
-30361
+    }
-30362
+}
-30363
 const CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampQueryDefaultInput`](crate::input::MalformedTimestampQueryDefaultInput) using modelled bindings.
     pub struct MalformedTimestampQueryDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampQueryDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedTimestampQueryDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampQueryDefaultInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_lists_test {
-30367
     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)
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonLists")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\n        }\n    ]\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_lists(move |input: crate::input::JsonListsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonListsInput {
                             string_list: ::std::option::Option::Some(vec![
                                 "foo".to_owned(),
                                 "bar".to_owned(),
                             ]),
                             string_set: ::std::option::Option::Some(
                                 vec!["foo".to_owned(), "bar".to_owned()]
                                     .try_into()
                                     .expect("this is only used in tests"),
                             ),
                             integer_list: ::std::option::Option::Some(vec![1, 2]),
                             boolean_list: ::std::option::Option::Some(vec![true, false]),
                             timestamp_list: ::std::option::Option::Some(vec![
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ]),
                             enum_list: ::std::option::Option::Some(vec![
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "0".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ]),
                             int_enum_list: ::std::option::Option::Some(vec![1, 2]),
                             nested_string_list: ::std::option::Option::Some(vec![
                                 vec!["foo".to_owned(), "bar".to_owned()],
                                 vec!["baz".to_owned(), "qux".to_owned()],
                             ]),
                             structure_list: ::std::option::Option::Some(vec![
                                 crate::model::StructureListMember {
                                     a: ::std::option::Option::Some("1".to_owned()),
                                     b: ::std::option::Option::Some("2".to_owned()),
                                 },
                                 crate::model::StructureListMember {
                                     a: ::std::option::Option::Some("3".to_owned()),
                                     b: ::std::option::Option::Some("4".to_owned()),
                                 },
                             ]),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonListsOutput {
                             string_list: ::std::option::Option::None,
                             string_set: ::std::option::Option::None,
                             integer_list: ::std::option::Option::None,
                             boolean_list: ::std::option::Option::None,
                             timestamp_list: ::std::option::Option::None,
                             enum_list: ::std::option::Option::None,
                             int_enum_list: ::std::option::Option::None,
                             nested_string_list: ::std::option::Option::None,
                             structure_list: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-30456
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampQueryDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampQueryDefaultInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_timestamp_query_default::de_malformed_timestamp_query_default_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_empty_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonLists")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"stringList\": []\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_lists(move |input: crate::input::JsonListsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonListsInput {
                             string_list: ::std::option::Option::Some(vec![]),
                             string_set: ::std::option::Option::None,
                             integer_list: ::std::option::Option::None,
                             boolean_list: ::std::option::Option::None,
                             timestamp_list: ::std::option::Option::None,
                             enum_list: ::std::option::Option::None,
                             int_enum_list: ::std::option::Option::None,
                             nested_string_list: ::std::option::Option::None,
                             structure_list: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonListsOutput {
                             string_list: ::std::option::Option::None,
                             string_set: ::std::option::Option::None,
                             integer_list: ::std::option::Option::None,
                             boolean_list: ::std::option::Option::None,
                             timestamp_list: ::std::option::Option::None,
                             enum_list: ::std::option::Option::None,
                             int_enum_list: ::std::option::Option::None,
                             nested_string_list: ::std::option::Option::None,
                             structure_list: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
         MalformedTimestampQueryDefaultInputFuture {
             inner: Box::pin(fut),
--
+        }
-30516
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampQueryDefaultOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Serializes JSON lists
     /// Test ID: RestJsonLists
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_response() {
         let output = crate::output::JsonListsOutput {
             string_list: ::std::option::Option::Some(vec!["foo".to_owned(), "bar".to_owned()]),
             string_set: ::std::option::Option::Some(
                 vec!["foo".to_owned(), "bar".to_owned()]
                     .try_into()
                     .expect("this is only used in tests"),
             ),
             integer_list: ::std::option::Option::Some(vec![1, 2]),
             boolean_list: ::std::option::Option::Some(vec![true, false]),
             timestamp_list: ::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ]),
             enum_list: ::std::option::Option::Some(vec![
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "0".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ]),
             int_enum_list: ::std::option::Option::Some(vec![1, 2]),
             nested_string_list: ::std::option::Option::Some(vec![
                 vec!["foo".to_owned(), "bar".to_owned()],
                 vec!["baz".to_owned(), "qux".to_owned()],
             ]),
             structure_list: ::std::option::Option::Some(vec![
                 crate::model::StructureListMember {
                     a: ::std::option::Option::Some("1".to_owned()),
                     b: ::std::option::Option::Some("2".to_owned()),
                 },
                 crate::model::StructureListMember {
                     a: ::std::option::Option::Some("3".to_owned()),
                     b: ::std::option::Option::Some("4".to_owned()),
                 },
             ]),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"stringList\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"stringSet\": [\n        \"foo\",\n        \"bar\"\n    ],\n    \"integerList\": [\n        1,\n        2\n    ],\n    \"booleanList\": [\n        true,\n        false\n    ],\n    \"timestampList\": [\n        1398796238,\n        1398796238\n    ],\n    \"enumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"intEnumList\": [\n        1,\n        2\n    ],\n    \"nestedStringList\": [\n        [\n            \"foo\",\n            \"bar\"\n        ],\n        [\n            \"baz\",\n            \"qux\"\n        ]\n    ],\n    \"myStructureList\": [\n        {\n            \"value\": \"1\",\n            \"other\": \"2\"\n        },\n        {\n            \"value\": \"3\",\n            \"other\": \"4\"\n        }\n    ]\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-30575
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampQueryDefaultError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Serializes empty JSON lists
     /// Test ID: RestJsonListsEmpty
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_lists_empty_response() {
         let output = crate::output::JsonListsOutput {
             string_list: ::std::option::Option::Some(vec![]),
             string_set: ::std::option::Option::None,
             integer_list: ::std::option::Option::None,
             boolean_list: ::std::option::Option::None,
             timestamp_list: ::std::option::Option::None,
             enum_list: ::std::option::Option::None,
             int_enum_list: ::std::option::Option::None,
             nested_string_list: ::std::option::Option::None,
             structure_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"stringList\": []\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-30611
+    }
-30612
+}
-30613
 const CONTENT_TYPE_MALFORMEDTIMESTAMPPATHEPOCH: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_RECURSIVESHAPES: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathEpochInput`](crate::input::MalformedTimestampPathEpochInput) using modelled bindings.
     pub struct MalformedTimestampPathEpochInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathEpochInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`RecursiveShapesInput`](crate::input::RecursiveShapesInput) using modelled bindings.
     pub struct RecursiveShapesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::RecursiveShapesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-30620
+    }
-30621
+}
-30622
 impl std::future::Future for MalformedTimestampPathEpochInputFuture {
 impl std::future::Future for RecursiveShapesInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathEpochInput,
         crate::input::RecursiveShapesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-30628
     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)
-30635
+    }
-30636
+}
-30637
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathEpochInput
     > for crate::input::RecursiveShapesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30646
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30650
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathEpochInputFuture;
     type Future = RecursiveShapesInputFuture;
-30653
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHEPOCH,
                 &CONTENT_TYPE_RECURSIVESHAPES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30661
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_epoch::de_malformed_timestamp_path_epoch_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30672
+                )
             },
         );
         MalformedTimestampPathEpochInputFuture {
         RecursiveShapesInputFuture {
             inner: Box::pin(fut),
-30677
+        }
-30678
+    }
-30679
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathEpochOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathEpochError
     > for crate::output::RecursiveShapesOutput
-30684
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
         match crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30693
+            }
--
+        }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod recursive_shapes_test {
-+
     /// Serializes recursive structures
     /// Test ID: RestJsonRecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_recursive_shapes_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/RecursiveShapes")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"nested\": {\n        \"foo\": \"Foo1\",\n        \"nested\": {\n            \"bar\": \"Bar1\",\n            \"recursiveMember\": {\n                \"foo\": \"Foo2\",\n                \"nested\": {\n                    \"bar\": \"Bar2\"\n                }\n            }\n        }\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .recursive_shapes(move |input: crate::input::RecursiveShapesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { let expected =
             crate::input::RecursiveShapesInput {
                 nested:
                     ::std::option::Option::Some(
                         crate::model::RecursiveShapesInputOutputNested1 {
                             foo:
                                 ::std::option::Option::Some(
                                     "Foo1".to_owned()
-+
+                                )
-+
+                            ,
                             nested:
                                 ::std::option::Option::Some(
                                     ::std::boxed::Box::new(
                                         crate::model::RecursiveShapesInputOutputNested2 {
                                             bar:
                                                 ::std::option::Option::Some(
                                                     "Bar1".to_owned()
-+
+                                                )
-+
+                                            ,
                                             recursive_member:
                                                 ::std::option::Option::Some(
                                                     crate::model::RecursiveShapesInputOutputNested1 {
                                                         foo:
                                                             ::std::option::Option::Some(
                                                                 "Foo2".to_owned()
-+
+                                                            )
-+
+                                                        ,
                                                         nested:
                                                             ::std::option::Option::Some(
                                                                 ::std::boxed::Box::new(
                                                                     crate::model::RecursiveShapesInputOutputNested2 {
                                                                         bar:
                                                                             ::std::option::Option::Some(
                                                                                 "Bar2".to_owned()
-+
+                                                                            )
-+
+                                                                        ,
                                                                         recursive_member:
                                                                             ::std::option::Option::None
-+
+                                                                        ,
-+
+                                                                    }
-+
+                                                                )
-+
+                                                            )
-+
+                                                        ,
-+
+                                                    }
-+
+                                                )
-+
+                                            ,
-+
+                                        }
-+
+                                    )
-+
+                                )
-+
+                            ,
-+
+                        }
-+
+                    )
-+
+                ,
-+
+            }
-+
+        ;
         ::pretty_assertions::assert_eq!(input, expected);
         let response =
             crate::output::RecursiveShapesOutput {
                 nested:
                     ::std::option::Option::None
-+
+                ,
-+
+            }
-+
+        ;
         response };
                                 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"
         );
-+
+    }
     /// Serializes recursive structures
     /// Test ID: RestJsonRecursiveShapes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_recursive_shapes_response() {
         let output = crate::output::RecursiveShapesOutput {
             nested: ::std::option::Option::Some(crate::model::RecursiveShapesInputOutputNested1 {
                 foo: ::std::option::Option::Some("Foo1".to_owned()),
                 nested: ::std::option::Option::Some(::std::boxed::Box::new(
                     crate::model::RecursiveShapesInputOutputNested2 {
                         bar: ::std::option::Option::Some("Bar1".to_owned()),
                         recursive_member: ::std::option::Option::Some(
                             crate::model::RecursiveShapesInputOutputNested1 {
                                 foo: ::std::option::Option::Some("Foo2".to_owned()),
                                 nested: ::std::option::Option::Some(::std::boxed::Box::new(
                                     crate::model::RecursiveShapesInputOutputNested2 {
                                         bar: ::std::option::Option::Some("Bar2".to_owned()),
                                         recursive_member: ::std::option::Option::None,
                                     },
                                 )),
                             },
                         ),
                     },
                 )),
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"nested\": {\n        \"foo\": \"Foo1\",\n        \"nested\": {\n            \"bar\": \"Bar1\",\n            \"recursiveMember\": {\n                \"foo\": \"Foo2\",\n                \"nested\": {\n                    \"bar\": \"Bar2\"\n                }\n            }\n        }\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-30840
+    }
-30841
+}
-30842
 const CONTENT_TYPE_MALFORMEDTIMESTAMPPATHHTTPDATE: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_JSONINTENUMS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathHttpDateInput`](crate::input::MalformedTimestampPathHttpDateInput) using modelled bindings.
     pub struct MalformedTimestampPathHttpDateInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathHttpDateInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`JsonIntEnumsInput`](crate::input::JsonIntEnumsInput) using modelled bindings.
     pub struct JsonIntEnumsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonIntEnumsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-30849
+    }
-30850
+}
-30851
 impl std::future::Future for MalformedTimestampPathHttpDateInputFuture {
 impl std::future::Future for JsonIntEnumsInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathHttpDateInput,
         crate::input::JsonIntEnumsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-30857
     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)
-30864
+    }
-30865
+}
-30866
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathHttpDateInput
     > for crate::input::JsonIntEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-30875
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-30879
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathHttpDateInputFuture;
     type Future = JsonIntEnumsInputFuture;
-30882
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHHTTPDATE,
                 &CONTENT_TYPE_JSONINTENUMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-30890
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_http_date::de_malformed_timestamp_path_http_date_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_json_int_enums::de_json_int_enums_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-30901
+                )
             },
         );
         MalformedTimestampPathHttpDateInputFuture {
         JsonIntEnumsInputFuture {
             inner: Box::pin(fut),
-30906
+        }
-30907
+    }
-30908
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathHttpDateOutput
     > for crate::output::JsonIntEnumsOutput
-30913
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-30922
+    }
-30923
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathHttpDateError
     > for crate::error::JsonIntEnumsError
-30928
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_error(&self) {
         match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
             },
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-30940
+            }
-30941
+        }
-30942
+    }
-30943
+}
-30944
 const CONTENT_TYPE_MALFORMEDTIMESTAMPPATHDEFAULT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedTimestampPathDefaultInput`](crate::input::MalformedTimestampPathDefaultInput) using modelled bindings.
     pub struct MalformedTimestampPathDefaultInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedTimestampPathDefaultInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedTimestampPathDefaultInputFuture {
     type Output = Result<
         crate::input::MalformedTimestampPathDefaultInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_int_enums_test {
-30948
     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)
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_int_enums_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonIntEnums")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_int_enums(move |input: crate::input::JsonIntEnumsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonIntEnumsInput {
                             integer_enum1: ::std::option::Option::Some(1),
                             integer_enum2: ::std::option::Option::Some(2),
                             integer_enum3: ::std::option::Option::Some(3),
                             integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
                             integer_enum_set: ::std::option::Option::Some(
                                 vec![1, 2].try_into().expect("this is only used in tests"),
                             ),
                             integer_enum_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("abc".to_owned(), 1);
                                 ret.insert("def".to_owned(), 2);
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonIntEnumsOutput {
                             integer_enum1: ::std::option::Option::None,
                             integer_enum2: ::std::option::Option::None,
                             integer_enum3: ::std::option::Option::None,
                             integer_enum_list: ::std::option::Option::None,
                             integer_enum_set: ::std::option::Option::None,
                             integer_enum_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-31006
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedTimestampPathDefaultInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedTimestampPathDefaultInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHDEFAULT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_timestamp_path_default::de_malformed_timestamp_path_default_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Serializes intEnums as integers
     /// Test ID: RestJsonJsonIntEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_int_enums_response() {
         let output = crate::output::JsonIntEnumsOutput {
             integer_enum1: ::std::option::Option::Some(1),
             integer_enum2: ::std::option::Option::Some(2),
             integer_enum3: ::std::option::Option::Some(3),
             integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
             integer_enum_set: ::std::option::Option::Some(
                 vec![1, 2].try_into().expect("this is only used in tests"),
             ),
             integer_enum_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("abc".to_owned(), 1);
                 ret.insert("def".to_owned(), 2);
                 ret
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"integerEnum1\": 1,\n    \"integerEnum2\": 2,\n    \"integerEnum3\": 3,\n    \"integerEnumList\": [\n        1,\n        2,\n        3\n    ],\n    \"integerEnumSet\": [\n        1,\n        2\n    ],\n    \"integerEnumMap\": {\n        \"abc\": 1,\n        \"def\": 2\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         MalformedTimestampPathDefaultInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedTimestampPathDefaultOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedTimestampPathDefaultError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-31044
+    }
-31045
+}
-31046
 const CONTENT_TYPE_MALFORMEDSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_JSONENUMS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedStringInput`](crate::input::MalformedStringInput) using modelled bindings.
     pub struct MalformedStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`JsonEnumsInput`](crate::input::JsonEnumsInput) using modelled bindings.
     pub struct JsonEnumsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonEnumsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-31053
+    }
-31054
+}
-31055
 impl std::future::Future for MalformedStringInputFuture {
 impl std::future::Future for JsonEnumsInputFuture {
     type Output = Result<
         crate::input::MalformedStringInput,
         crate::input::JsonEnumsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-31061
     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)
-31068
+    }
-31069
+}
-31070
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedStringInput
     > for crate::input::JsonEnumsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-31079
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-31083
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedStringInputFuture;
     type Future = JsonEnumsInputFuture;
-31086
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDSTRING,
                 &CONTENT_TYPE_JSONENUMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-31094
+            }
             crate::protocol_serde::shape_malformed_string::de_malformed_string_http_request(request)
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-31105
+                )
             },
         );
         MalformedStringInputFuture {
         JsonEnumsInputFuture {
             inner: Box::pin(fut),
-31110
+        }
-31111
+    }
-31112
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedStringOutput
     > for crate::output::JsonEnumsOutput
-31117
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_string::ser_malformed_string_http_response(
             self,
         ) {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-31124
+            }
-31125
+        }
-31126
+    }
-31127
+}
--
 const CONTENT_TYPE_MALFORMEDDOUBLE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedDoubleInput`](crate::input::MalformedDoubleInput) using modelled bindings.
     pub struct MalformedDoubleInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedDoubleInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonEnumsError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-31146
+    }
-31147
+}
-31148
 impl std::future::Future for MalformedDoubleInputFuture {
     type Output = Result<
         crate::input::MalformedDoubleInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_enums_test {
-31152
     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)
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_enums_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/JsonEnums")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"fooEnum1\": \"Foo\",\n    \"fooEnum2\": \"0\",\n    \"fooEnum3\": \"1\",\n    \"fooEnumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumSet\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumMap\": {\n        \"hi\": \"Foo\",\n        \"zero\": \"0\"\n    }\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_enums(move |input: crate::input::JsonEnumsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonEnumsInput {
                             foo_enum1: ::std::option::Option::Some(
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             foo_enum2: ::std::option::Option::Some(
                                 "0".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             foo_enum3: ::std::option::Option::Some(
                                 "1".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             foo_enum_list: ::std::option::Option::Some(vec![
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "0".parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ]),
                             foo_enum_set: ::std::option::Option::Some(
                                 vec![
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                     "0".parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
-+
+                                ]
                                 .try_into()
                                 .expect("this is only used in tests"),
                             ),
                             foo_enum_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "hi".to_owned(),
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 );
                                 ret.insert(
                                     "zero".to_owned(),
                                     "0".parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 );
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonEnumsOutput {
                             foo_enum1: ::std::option::Option::None,
                             foo_enum2: ::std::option::Option::None,
                             foo_enum3: ::std::option::Option::None,
                             foo_enum_list: ::std::option::Option::None,
                             foo_enum_set: ::std::option::Option::None,
                             foo_enum_map: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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"
         );
-31243
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedDoubleInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedDoubleInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDDOUBLE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_double::de_malformed_double_http_request(request)
                 .await
                 .map_err(Into::into)
     /// Serializes simple scalar properties
     /// Test ID: RestJsonJsonEnums
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_enums_response() {
         let output = crate::output::JsonEnumsOutput {
             foo_enum1: ::std::option::Option::Some(
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             foo_enum2: ::std::option::Option::Some(
                 "0".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             foo_enum3: ::std::option::Option::Some(
                 "1".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             foo_enum_list: ::std::option::Option::Some(vec![
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "0".parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ]),
             foo_enum_set: ::std::option::Option::Some(
                 vec![
                     "Foo"
                         .parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
                     "0".parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
-+
+                ]
                 .try_into()
                 .expect("this is only used in tests"),
             ),
             foo_enum_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "hi".to_owned(),
                     "Foo"
                         .parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
                 );
                 ret.insert(
                     "zero".to_owned(),
                     "0".parse::<crate::model::FooEnum>()
                         .expect("static value validated to member"),
                 );
                 ret
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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, "{\n    \"fooEnum1\": \"Foo\",\n    \"fooEnum2\": \"0\",\n    \"fooEnum3\": \"1\",\n    \"fooEnumList\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumSet\": [\n        \"Foo\",\n        \"0\"\n    ],\n    \"fooEnumMap\": {\n        \"hi\": \"Foo\",\n        \"zero\": \"0\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         MalformedDoubleInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedDoubleOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedDoubleError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_error(&self)
--
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-31314
+    }
-31315
+}
-31316
 const CONTENT_TYPE_MALFORMEDFLOAT: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_JSONTIMESTAMPS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedFloatInput`](crate::input::MalformedFloatInput) using modelled bindings.
     pub struct MalformedFloatInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedFloatInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`JsonTimestampsInput`](crate::input::JsonTimestampsInput) using modelled bindings.
     pub struct JsonTimestampsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonTimestampsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-31323
+    }
-31324
+}
-31325
 impl std::future::Future for MalformedFloatInputFuture {
 impl std::future::Future for JsonTimestampsInputFuture {
     type Output = Result<
         crate::input::MalformedFloatInput,
         crate::input::JsonTimestampsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-31331
     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)
-31338
+    }
-31339
+}
-31340
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedFloatInput
     > for crate::input::JsonTimestampsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-31349
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-31353
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedFloatInputFuture;
     type Future = JsonTimestampsInputFuture;
-31356
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDFLOAT,
                 &CONTENT_TYPE_JSONTIMESTAMPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-31364
+            }
             crate::protocol_serde::shape_malformed_float::de_malformed_float_http_request(request)
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-31375
+                )
             },
         );
         MalformedFloatInputFuture {
         JsonTimestampsInputFuture {
             inner: Box::pin(fut),
-31380
+        }
-31381
+    }
-31382
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedFloatOutput
     > for crate::output::JsonTimestampsOutput
-31387
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_response(self)
         match crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_http_response(self)
-31390
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-31395
+            }
-31396
+        }
-31397
+    }
-31398
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedFloatError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDLONG: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedLongInput`](crate::input::MalformedLongInput) using modelled bindings.
     pub struct MalformedLongInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedLongInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
-31399
 impl std::future::Future for MalformedLongInputFuture {
     type Output = Result<
         crate::input::MalformedLongInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod json_timestamps_test {
-31403
     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)
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"normal\": 1398796238\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             normal: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-31463
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLongInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLongInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLONG,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_long::de_malformed_long_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             date_time: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_on_target_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             date_time_on_target: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"epochSeconds\": 1398796238\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             epoch_seconds: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"epochSecondsOnTarget\": 1398796238\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             epoch_seconds_on_target: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             http_date: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
         MalformedLongInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLongOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedLongError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDSHORT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedShortInput`](crate::input::MalformedShortInput) using modelled bindings.
     pub struct MalformedShortInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedShortInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-31771
+    }
--
+}
--
 impl std::future::Future for MalformedShortInputFuture {
     type Output = Result<
         crate::input::MalformedShortInput,
         ::aws_smithy_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)
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_on_target_format_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/JsonTimestamps")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .json_timestamps(move |input: crate::input::JsonTimestampsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::JsonTimestampsInput {
                             http_date_on_target: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1398796238, 0_f64,
                                 ),
                             ),
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::JsonTimestampsOutput {
                             normal: ::std::option::Option::None,
                             date_time: ::std::option::Option::None,
                             date_time_on_target: ::std::option::Option::None,
                             epoch_seconds: ::std::option::Option::None,
                             epoch_seconds_on_target: ::std::option::Option::None,
                             http_date: ::std::option::Option::None,
                             http_date_on_target: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-31833
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedShortInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedShortInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDSHORT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_short::de_malformed_short_http_request(request)
                 .await
                 .map_err(Into::into)
     /// Tests how normal timestamps are serialized
     /// Test ID: RestJsonJsonTimestamps
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_response() {
         let output = crate::output::JsonTimestampsOutput {
             normal: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedShortInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedShortOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_response(self)
--
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedShortError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDBYTE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedByteInput`](crate::input::MalformedByteInput) using modelled bindings.
     pub struct MalformedByteInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedByteInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedByteInputFuture {
     type Output = Result<
         crate::input::MalformedByteInput,
         ::aws_smithy_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)
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"normal\": 1398796238\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-31869
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedByteInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedByteInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBYTE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_byte::de_malformed_byte_http_request(request)
                 .await
                 .map_err(Into::into)
     /// Ensures that the timestampFormat of date-time works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             date_time: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedByteInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedByteOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedByteError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"dateTime\": \"2014-04-29T18:30:38Z\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-31905
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDBLOB: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedBlobInput`](crate::input::MalformedBlobInput) using modelled bindings.
     pub struct MalformedBlobInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBlobInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// Ensures that the timestampFormat of date-time on the target shape works like normal timestamps
     /// Test ID: RestJsonJsonTimestampsWithDateTimeOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_date_time_on_target_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             date_time_on_target: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"dateTimeOnTarget\": \"2014-04-29T18:30:38Z\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-31941
+    }
--
+}
--
 impl std::future::Future for MalformedBlobInputFuture {
     type Output = Result<
         crate::input::MalformedBlobInput,
         ::aws_smithy_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)
     /// Ensures that the timestampFormat of epoch-seconds works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             epoch_seconds: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"epochSeconds\": 1398796238\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-31977
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBlobInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBlobInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBLOB,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_blob::de_malformed_blob_http_request(request)
                 .await
                 .map_err(Into::into)
     /// Ensures that the timestampFormat of epoch-seconds on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithEpochSecondsOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_epoch_seconds_on_target_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             epoch_seconds_on_target: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"epochSecondsOnTarget\": 1398796238\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
     /// Ensures that the timestampFormat of http-date works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             http_date: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date_on_target: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedBlobInputFuture {
             inner: Box::pin(fut),
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"httpDate\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-32049
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBlobOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_blob::ser_malformed_blob_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Ensures that the timestampFormat of http-date on the target shape works
     /// Test ID: RestJsonJsonTimestampsWithHttpDateOnTargetFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_json_timestamps_with_http_date_on_target_format_response() {
         let output = crate::output::JsonTimestampsOutput {
             http_date_on_target: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1398796238, 0_f64),
             ),
             normal: ::std::option::Option::None,
             date_time: ::std::option::Option::None,
             date_time_on_target: ::std::option::Option::None,
             epoch_seconds: ::std::option::Option::None,
             epoch_seconds_on_target: ::std::option::Option::None,
             http_date: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"httpDateOnTarget\": \"Tue, 29 Apr 2014 18:30:38 GMT\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-32085
+    }
-32086
+}
-32087
 const CONTENT_TYPE_MALFORMEDMAP: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_SIMPLESCALARPROPERTIES: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedMapInput`](crate::input::MalformedMapInput) using modelled bindings.
     pub struct MalformedMapInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedMapInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`SimpleScalarPropertiesInput`](crate::input::SimpleScalarPropertiesInput) using modelled bindings.
     pub struct SimpleScalarPropertiesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SimpleScalarPropertiesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-32094
+    }
-32095
+}
-32096
 impl std::future::Future for MalformedMapInputFuture {
 impl std::future::Future for SimpleScalarPropertiesInputFuture {
     type Output = Result<
         crate::input::MalformedMapInput,
         crate::input::SimpleScalarPropertiesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-32102
     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)
-32109
+    }
-32110
+}
-32111
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedMapInput
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-32120
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-32124
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedMapInputFuture;
     type Future = SimpleScalarPropertiesInputFuture;
-32127
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDMAP,
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-32135
+            }
             crate::protocol_serde::shape_malformed_map::de_malformed_map_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-32146
+                )
             },
         );
         MalformedMapInputFuture {
         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),
-32151
+        }
-32152
+    }
-32153
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedMapOutput
     > for crate::output::SimpleScalarPropertiesOutput
-32158
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_map::ser_malformed_map_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDLIST: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedListInput`](crate::input::MalformedListInput) using modelled bindings.
     pub struct MalformedListInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedListInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-32167
+    }
-32168
+}
-32169
 impl std::future::Future for MalformedListInputFuture {
     type Output = Result<
         crate::input::MalformedListInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod simple_scalar_properties_test {
-32173
     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)
     /// Serializes simple scalar properties
     /// Test ID: RestJsonSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_simple_scalar_properties_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SimpleScalarProperties")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .header("X-Foo", "Foo")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"stringValue\": \"string\",\n    \"trueBooleanValue\": true,\n    \"falseBooleanValue\": false,\n    \"byteValue\": 1,\n    \"shortValue\": 2,\n    \"integerValue\": 3,\n    \"longValue\": 4,\n    \"floatValue\": 5.5,\n    \"DoubleDribble\": 6.5\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::SimpleScalarPropertiesInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             string_value: ::std::option::Option::Some("string".to_owned()),
                             true_boolean_value: ::std::option::Option::Some(true),
                             false_boolean_value: ::std::option::Option::Some(false),
                             byte_value: ::std::option::Option::Some(1),
                             short_value: ::std::option::Option::Some(2),
                             integer_value: ::std::option::Option::Some(3),
                             long_value: ::std::option::Option::Some(4),
                             float_value: ::std::option::Option::Some(5.5_f32),
                             double_value: ::std::option::Option::Some(6.5_f64),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.string_value,
                             expected.string_value,
                             "Unexpected value for `string_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.true_boolean_value,
                             expected.true_boolean_value,
                             "Unexpected value for `true_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.false_boolean_value,
                             expected.false_boolean_value,
                             "Unexpected value for `false_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.byte_value,
                             expected.byte_value,
                             "Unexpected value for `byte_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short_value,
                             expected.short_value,
                             "Unexpected value for `short_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer_value,
                             expected.integer_value,
                             "Unexpected value for `integer_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long_value,
                             expected.long_value,
                             "Unexpected value for `long_value`"
                         );
                         assert!(
                             input.float_value.float_equals(&expected.float_value),
                             "Unexpected value for `float_value` {:?} vs. {:?}",
                             expected.float_value,
                             input.float_value
                         );
                         assert!(
                             input.double_value.float_equals(&expected.double_value),
                             "Unexpected value for `double_value` {:?} vs. {:?}",
                             expected.double_value,
                             input.double_value
                         );
                         let response = crate::output::SimpleScalarPropertiesOutput {
                             foo: ::std::option::Option::None,
                             string_value: ::std::option::Option::None,
                             true_boolean_value: ::std::option::Option::None,
                             false_boolean_value: ::std::option::Option::None,
                             byte_value: ::std::option::Option::None,
                             short_value: ::std::option::Option::None,
                             integer_value: ::std::option::Option::None,
                             long_value: ::std::option::Option::None,
                             float_value: ::std::option::Option::None,
                             double_value: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-32285
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedListInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedListInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLIST,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
     /// Rest Json should not deserialize null structure values
     /// Test ID: RestJsonServersDontSerializeNullStructureValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_servers_dont_serialize_null_structure_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SimpleScalarProperties")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"stringValue\": null\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::SimpleScalarPropertiesInput {
                             foo: ::std::option::Option::None,
                             string_value: ::std::option::Option::None,
                             true_boolean_value: ::std::option::Option::None,
                             false_boolean_value: ::std::option::Option::None,
                             byte_value: ::std::option::Option::None,
                             short_value: ::std::option::Option::None,
                             integer_value: ::std::option::Option::None,
                             long_value: ::std::option::Option::None,
                             float_value: ::std::option::Option::None,
                             double_value: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.string_value,
                             expected.string_value,
                             "Unexpected value for `string_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.true_boolean_value,
                             expected.true_boolean_value,
                             "Unexpected value for `true_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.false_boolean_value,
                             expected.false_boolean_value,
                             "Unexpected value for `false_boolean_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.byte_value,
                             expected.byte_value,
                             "Unexpected value for `byte_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short_value,
                             expected.short_value,
                             "Unexpected value for `short_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer_value,
                             expected.integer_value,
                             "Unexpected value for `integer_value`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long_value,
                             expected.long_value,
                             "Unexpected value for `long_value`"
                         );
                         assert!(
                             input.float_value.float_equals(&expected.float_value),
                             "Unexpected value for `float_value` {:?} vs. {:?}",
                             expected.float_value,
                             input.float_value
                         );
                         assert!(
                             input.double_value.float_equals(&expected.double_value),
                             "Unexpected value for `double_value` {:?} vs. {:?}",
                             expected.double_value,
                             input.double_value
                         );
                         let response = crate::output::SimpleScalarPropertiesOutput {
                             foo: ::std::option::Option::None,
                             string_value: ::std::option::Option::None,
                             true_boolean_value: ::std::option::Option::None,
                             false_boolean_value: ::std::option::Option::None,
                             byte_value: ::std::option::Option::None,
                             short_value: ::std::option::Option::None,
                             integer_value: ::std::option::Option::None,
                             long_value: ::std::option::Option::None,
                             float_value: ::std::option::Option::None,
                             double_value: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Supports handling NaN float values.
     /// Test ID: RestJsonSupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SimpleScalarProperties")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"floatValue\": \"NaN\",\n    \"DoubleDribble\": \"NaN\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::SimpleScalarPropertiesInput {
                 float_value:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 double_value:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 foo:
                     ::std::option::Option::None
-+
+                ,
                 string_value:
                     ::std::option::Option::None
-+
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 byte_value:
                     ::std::option::Option::None
-+
+                ,
                 short_value:
                     ::std::option::Option::None
-+
+                ,
                 integer_value:
                     ::std::option::Option::None
-+
+                ,
                 long_value:
                     ::std::option::Option::None
-+
+                ,
-+
+            }
-+
+        ;
         ::pretty_assertions::assert_eq!(input.foo, expected.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(input.string_value, expected.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(input.true_boolean_value, expected.true_boolean_value, "Unexpected value for `true_boolean_value`");
         ::pretty_assertions::assert_eq!(input.false_boolean_value, expected.false_boolean_value, "Unexpected value for `false_boolean_value`");
         ::pretty_assertions::assert_eq!(input.byte_value, expected.byte_value, "Unexpected value for `byte_value`");
         ::pretty_assertions::assert_eq!(input.short_value, expected.short_value, "Unexpected value for `short_value`");
         ::pretty_assertions::assert_eq!(input.integer_value, expected.integer_value, "Unexpected value for `integer_value`");
         ::pretty_assertions::assert_eq!(input.long_value, expected.long_value, "Unexpected value for `long_value`");
         assert!(input.float_value.float_equals(&expected.float_value),
                                             "Unexpected value for `float_value` {:?} vs. {:?}", expected.float_value, input.float_value);
         assert!(input.double_value.float_equals(&expected.double_value),
                                             "Unexpected value for `double_value` {:?} vs. {:?}", expected.double_value, input.double_value);
         let response =
             crate::output::SimpleScalarPropertiesOutput {
                 foo:
                     ::std::option::Option::None
-+
+                ,
                 string_value:
                     ::std::option::Option::None
-+
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 byte_value:
                     ::std::option::Option::None
-+
+                ,
                 short_value:
                     ::std::option::Option::None
-+
+                ,
                 integer_value:
                     ::std::option::Option::None
-+
+                ,
                 long_value:
                     ::std::option::Option::None
-+
+                ,
                 float_value:
                     ::std::option::Option::None
-+
+                ,
                 double_value:
                     ::std::option::Option::None
-+
+                ,
-32506
+            }
             crate::protocol_serde::shape_malformed_list::de_malformed_list_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
-+
+        ;
         response };
                                 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"
         );
         MalformedListInputFuture {
             inner: Box::pin(fut),
--
+        }
-32521
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedListOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_list::ser_malformed_list_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
     /// Supports handling Infinity float values.
     /// Test ID: RestJsonSupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/SimpleScalarProperties")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"floatValue\": \"Infinity\",\n    \"DoubleDribble\": \"Infinity\"\n}"
                         .as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::SimpleScalarPropertiesInput {
                 float_value:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 double_value:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 foo:
                     ::std::option::Option::None
-+
+                ,
                 string_value:
                     ::std::option::Option::None
-+
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 byte_value:
                     ::std::option::Option::None
-+
+                ,
                 short_value:
                     ::std::option::Option::None
-+
+                ,
                 integer_value:
                     ::std::option::Option::None
-+
+                ,
                 long_value:
                     ::std::option::Option::None
-+
+                ,
-32583
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDBOOLEAN: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedBooleanInput`](crate::input::MalformedBooleanInput) using modelled bindings.
     pub struct MalformedBooleanInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedBooleanInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedBooleanInputFuture {
     type Output = Result<
         crate::input::MalformedBooleanInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedBooleanInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedBooleanInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDBOOLEAN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+        ;
         ::pretty_assertions::assert_eq!(input.foo, expected.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(input.string_value, expected.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(input.true_boolean_value, expected.true_boolean_value, "Unexpected value for `true_boolean_value`");
         ::pretty_assertions::assert_eq!(input.false_boolean_value, expected.false_boolean_value, "Unexpected value for `false_boolean_value`");
         ::pretty_assertions::assert_eq!(input.byte_value, expected.byte_value, "Unexpected value for `byte_value`");
         ::pretty_assertions::assert_eq!(input.short_value, expected.short_value, "Unexpected value for `short_value`");
         ::pretty_assertions::assert_eq!(input.integer_value, expected.integer_value, "Unexpected value for `integer_value`");
         ::pretty_assertions::assert_eq!(input.long_value, expected.long_value, "Unexpected value for `long_value`");
         assert!(input.float_value.float_equals(&expected.float_value),
                                             "Unexpected value for `float_value` {:?} vs. {:?}", expected.float_value, input.float_value);
         assert!(input.double_value.float_equals(&expected.double_value),
                                             "Unexpected value for `double_value` {:?} vs. {:?}", expected.double_value, input.double_value);
         let response =
             crate::output::SimpleScalarPropertiesOutput {
                 foo:
                     ::std::option::Option::None
-+
+                ,
                 string_value:
                     ::std::option::Option::None
-+
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 byte_value:
                     ::std::option::Option::None
-+
+                ,
                 short_value:
                     ::std::option::Option::None
-+
+                ,
                 integer_value:
                     ::std::option::Option::None
-+
+                ,
                 long_value:
                     ::std::option::Option::None
-+
+                ,
                 float_value:
                     ::std::option::Option::None
-+
+                ,
                 double_value:
                     ::std::option::Option::None
-+
+                ,
-32629
+            }
             crate::protocol_serde::shape_malformed_boolean::de_malformed_boolean_http_request(
                 request,
--
+            )
-+
+        ;
         response };
                                 sender.send(()).await.expect("receiver dropped early");
                                 result
-+
+                            }
                         })
                         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
             .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"
         );
         MalformedBooleanInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedBooleanOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-32644
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedBooleanError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
     /// Supports handling -Infinity float values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_inputs_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/SimpleScalarProperties")
                         .method("PUT")
         .header("Content-Type", "application/json")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("{\n    \"floatValue\": \"-Infinity\",\n    \"DoubleDribble\": \"-Infinity\"\n}".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .simple_scalar_properties(move |input: crate::input::SimpleScalarPropertiesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::SimpleScalarPropertiesInput {
                 float_value:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 double_value:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 foo:
                     ::std::option::Option::None
-+
+                ,
                 string_value:
                     ::std::option::Option::None
-+
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 byte_value:
                     ::std::option::Option::None
-+
+                ,
                 short_value:
                     ::std::option::Option::None
-+
+                ,
                 integer_value:
                     ::std::option::Option::None
-+
+                ,
                 long_value:
                     ::std::option::Option::None
-+
+                ,
-32700
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+        ;
         ::pretty_assertions::assert_eq!(input.foo, expected.foo, "Unexpected value for `foo`");
         ::pretty_assertions::assert_eq!(input.string_value, expected.string_value, "Unexpected value for `string_value`");
         ::pretty_assertions::assert_eq!(input.true_boolean_value, expected.true_boolean_value, "Unexpected value for `true_boolean_value`");
         ::pretty_assertions::assert_eq!(input.false_boolean_value, expected.false_boolean_value, "Unexpected value for `false_boolean_value`");
         ::pretty_assertions::assert_eq!(input.byte_value, expected.byte_value, "Unexpected value for `byte_value`");
         ::pretty_assertions::assert_eq!(input.short_value, expected.short_value, "Unexpected value for `short_value`");
         ::pretty_assertions::assert_eq!(input.integer_value, expected.integer_value, "Unexpected value for `integer_value`");
         ::pretty_assertions::assert_eq!(input.long_value, expected.long_value, "Unexpected value for `long_value`");
         assert!(input.float_value.float_equals(&expected.float_value),
                                             "Unexpected value for `float_value` {:?} vs. {:?}", expected.float_value, input.float_value);
         assert!(input.double_value.float_equals(&expected.double_value),
                                             "Unexpected value for `double_value` {:?} vs. {:?}", expected.double_value, input.double_value);
         let response =
             crate::output::SimpleScalarPropertiesOutput {
                 foo:
                     ::std::option::Option::None
-+
+                ,
                 string_value:
                     ::std::option::Option::None
-+
+                ,
                 true_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 false_boolean_value:
                     ::std::option::Option::None
-+
+                ,
                 byte_value:
                     ::std::option::Option::None
-+
+                ,
                 short_value:
                     ::std::option::Option::None
-+
+                ,
                 integer_value:
                     ::std::option::Option::None
-+
+                ,
                 long_value:
                     ::std::option::Option::None
-+
+                ,
                 float_value:
                     ::std::option::Option::None
-+
+                ,
                 double_value:
                     ::std::option::Option::None
-+
+                ,
-32746
+            }
--
+        }
-+
+        ;
         response };
                                 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"
         );
-32761
+    }
--
+}
--
 const CONTENT_TYPE_MALFORMEDUNION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedUnionInput`](crate::input::MalformedUnionInput) using modelled bindings.
     pub struct MalformedUnionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedUnionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// Serializes simple scalar properties
     /// Test ID: RestJsonSimpleScalarProperties
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_simple_scalar_properties_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             string_value: ::std::option::Option::Some("string".to_owned()),
             true_boolean_value: ::std::option::Option::Some(true),
             false_boolean_value: ::std::option::Option::Some(false),
             byte_value: ::std::option::Option::Some(1),
             short_value: ::std::option::Option::Some(2),
             integer_value: ::std::option::Option::Some(3),
             long_value: ::std::option::Option::Some(4),
             float_value: ::std::option::Option::Some(5.5_f32),
             double_value: ::std::option::Option::Some(6.5_f64),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json"), ("X-Foo", "Foo")];
         ::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, "{\n    \"stringValue\": \"string\",\n    \"trueBooleanValue\": true,\n    \"falseBooleanValue\": false,\n    \"byteValue\": 1,\n    \"shortValue\": 2,\n    \"integerValue\": 3,\n    \"longValue\": 4,\n    \"floatValue\": 5.5,\n    \"DoubleDribble\": 6.5\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
-32796
+    }
--
+}
--
 impl std::future::Future for MalformedUnionInputFuture {
     type Output = Result<
         crate::input::MalformedUnionInput,
         ::aws_smithy_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)
     /// Rest Json should not serialize null structure values
     /// Test ID: RestJsonServersDontSerializeNullStructureValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_servers_dont_serialize_null_structure_values_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             string_value: ::std::option::Option::None,
             foo: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
             float_value: ::std::option::Option::None,
             double_value: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-32833
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUnionInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDUNION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_union::de_malformed_union_http_request(request)
                 .await
                 .map_err(Into::into)
     /// Supports handling NaN float values.
     /// Test ID: RestJsonSupportsNaNFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_inputs_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             float_value: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             double_value: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             foo: ::std::option::Option::None,
             string_value: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"floatValue\": \"NaN\",\n    \"DoubleDribble\": \"NaN\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
     /// Supports handling Infinity float values.
     /// Test ID: RestJsonSupportsInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_inputs_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             float_value: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             double_value: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             foo: ::std::option::Option::None,
             string_value: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedUnionInputFuture {
             inner: Box::pin(fut),
--
+        }
         let expected_headers = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"floatValue\": \"Infinity\",\n    \"DoubleDribble\": \"Infinity\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-32919
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUnionOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_union::ser_malformed_union_http_response(self)
--
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Supports handling -Infinity float values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_inputs_response() {
         let output = crate::output::SimpleScalarPropertiesOutput {
             float_value: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             double_value: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             foo: ::std::option::Option::None,
             string_value: ::std::option::Option::None,
             true_boolean_value: ::std::option::Option::None,
             false_boolean_value: ::std::option::Option::None,
             byte_value: ::std::option::Option::None,
             short_value: ::std::option::Option::None,
             integer_value: ::std::option::Option::None,
             long_value: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"floatValue\": \"-Infinity\",\n    \"DoubleDribble\": \"-Infinity\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-32962
+    }
-32963
+}
-32964
 const CONTENT_TYPE_MALFORMEDINTEGER: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_GREETINGWITHERRORS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedIntegerInput`](crate::input::MalformedIntegerInput) using modelled bindings.
     pub struct MalformedIntegerInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedIntegerInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`GreetingWithErrorsInput`](crate::input::GreetingWithErrorsInput) using modelled bindings.
     pub struct GreetingWithErrorsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::GreetingWithErrorsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-32971
+    }
-32972
+}
-32973
 impl std::future::Future for MalformedIntegerInputFuture {
 impl std::future::Future for GreetingWithErrorsInputFuture {
     type Output = Result<
         crate::input::MalformedIntegerInput,
         crate::input::GreetingWithErrorsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-32979
     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)
-32986
+    }
-32987
+}
-32988
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedIntegerInput
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-32997
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33001
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedIntegerInputFuture;
     type Future = GreetingWithErrorsInputFuture;
-33004
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDINTEGER,
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33012
+            }
             crate::protocol_serde::shape_malformed_integer::de_malformed_integer_http_request(
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-33015
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33025
+                )
             },
         );
         MalformedIntegerInputFuture {
         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),
-33030
+        }
-33031
+    }
-33032
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedIntegerOutput
     > for crate::output::GreetingWithErrorsOutput
-33037
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-33046
+    }
-33047
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::MalformedIntegerError
     > for crate::error::GreetingWithErrorsError
-33052
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_error(
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-33062
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33066
+            }
-33067
+        }
-33068
+    }
-33069
+}
-33070
 const CONTENT_TYPE_MALFORMEDREQUESTBODY: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MalformedRequestBodyInput`](crate::input::MalformedRequestBodyInput) using modelled bindings.
     pub struct MalformedRequestBodyInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MalformedRequestBodyInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MalformedRequestBodyInputFuture {
     type Output = Result<
         crate::input::MalformedRequestBodyInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRequestBodyInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRequestBodyInputFuture;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod greeting_with_errors_test {
-33074
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDREQUESTBODY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_malformed_request_body::de_malformed_request_body_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Ensures that operations with errors successfully know how
     /// to deserialize a successful response. As of January 2021,
     /// server implementations are expected to respond with a
     /// JSON object regardless of if the output parameters are
     /// empty.
     /// Test ID: RestJsonGreetingWithErrors
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_greeting_with_errors_response() {
         let output = crate::output::GreetingWithErrorsOutput {
             greeting: ::std::option::Option::Some("Hello".to_owned()),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         MalformedRequestBodyInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRequestBodyOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_request_body::ser_malformed_request_body_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPCHECKSUMREQUIRED: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpChecksumRequiredInput`](crate::input::HttpChecksumRequiredInput) using modelled bindings.
     pub struct HttpChecksumRequiredInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpChecksumRequiredInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpChecksumRequiredInputFuture {
     type Output = Result<
         crate::input::HttpChecksumRequiredInput,
         ::aws_smithy_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)
         let expected_headers = [("X-Greeting", "Hello")];
         ::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("application/json"),
         ));
-33106
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpChecksumRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpChecksumRequiredInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPCHECKSUMREQUIRED,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_checksum_required::de_http_checksum_required_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Parses simple JSON errors
     /// Test ID: RestJsonInvalidGreetingError
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_invalid_greeting_error_response() {
         let output = crate::error::InvalidGreeting {
             message: ::std::option::Option::Some("Hi".to_owned()),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         let output = crate::error::GreetingWithErrorsError::InvalidGreeting(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         HttpChecksumRequiredInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpChecksumRequiredOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_checksum_required::ser_http_checksum_required_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_HOSTWITHPATHOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HostWithPathOperationInput`](crate::input::HostWithPathOperationInput) using modelled bindings.
     pub struct HostWithPathOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HostWithPathOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HostWithPathOperationInputFuture {
     type Output = Result<
         crate::input::HostWithPathOperationInput,
         ::aws_smithy_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)
         let expected_headers = [
             ("Content-Type", "application/json"),
             ("X-Amzn-Errortype", "InvalidGreeting"),
         ];
         ::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,
             "{\n    \"Message\": \"Hi\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-33138
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HostWithPathOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HostWithPathOperationInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HOSTWITHPATHOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Serializes a complex error with no message member
     /// Test ID: RestJsonComplexErrorWithNoMessage
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_complex_error_with_no_message_response() {
         let output = crate::error::ComplexError {
             header: ::std::option::Option::Some("Header".to_owned()),
             top_level: ::std::option::Option::Some("Top level".to_owned()),
             nested: ::std::option::Option::Some(crate::model::ComplexNestedErrorData {
                 foo: ::std::option::Option::Some("bar".to_owned()),
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         let output = crate::error::GreetingWithErrorsError::ComplexError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(403).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [
             ("Content-Type", "application/json"),
             ("X-Amzn-Errortype", "ComplexError"),
             ("X-Header", "Header"),
         ];
         ::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, "{\n    \"TopLevel\": \"Top level\",\n    \"Nested\": {\n        \"Fooooo\": \"bar\"\n    }\n}", ::aws_smithy_protocol_test::MediaType::from("application/json"))
         );
         HostWithPathOperationInputFuture {
             inner: Box::pin(fut),
--
+        }
-33173
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HostWithPathOperationOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Test ID: RestJsonEmptyComplexErrorWithNoMessage
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_empty_complex_error_with_no_message_response() {
         let output = crate::error::ComplexError {
             header: ::std::option::Option::None,
             top_level: ::std::option::Option::None,
             nested: ::std::option::Option::None,
         };
         let output = crate::error::GreetingWithErrorsError::ComplexError(output);
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(403).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [
             ("Content-Type", "application/json"),
             ("X-Amzn-Errortype", "ComplexError"),
         ];
         ::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("application/json"),
         ));
-33206
+    }
-33207
+}
-33208
 const CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 static CONTENT_TYPE_STREAMINGTRAITSWITHMEDIATYPE: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EndpointWithHostLabelOperationInput`](crate::input::EndpointWithHostLabelOperationInput) using modelled bindings.
     pub struct EndpointWithHostLabelOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointWithHostLabelOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`StreamingTraitsWithMediaTypeInput`](crate::input::StreamingTraitsWithMediaTypeInput) using modelled bindings.
     pub struct StreamingTraitsWithMediaTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsWithMediaTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-33220
+    }
-33221
+}
-33222
 impl std::future::Future for EndpointWithHostLabelOperationInputFuture {
 impl std::future::Future for StreamingTraitsWithMediaTypeInputFuture {
     type Output = Result<
         crate::input::EndpointWithHostLabelOperationInput,
         crate::input::StreamingTraitsWithMediaTypeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-33228
     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)
-33235
+    }
-33236
+}
-33237
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointWithHostLabelOperationInput
     > for crate::input::StreamingTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33246
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33251
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointWithHostLabelOperationInputFuture;
     type Future = StreamingTraitsWithMediaTypeInputFuture;
-33254
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
                 &CONTENT_TYPE_STREAMINGTRAITSWITHMEDIATYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33262
+            }
             crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
             crate::protocol_serde::shape_streaming_traits_with_media_type::de_streaming_traits_with_media_type_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33273
+                )
             },
         );
         EndpointWithHostLabelOperationInputFuture {
         StreamingTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
-33278
+        }
-33279
+    }
-33280
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointWithHostLabelOperationOutput
     > for crate::output::StreamingTraitsWithMediaTypeOutput
-33285
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
         match crate::protocol_serde::shape_streaming_traits_with_media_type::ser_streaming_traits_with_media_type_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33292
+                        }
-33293
+                    }
-33294
+    }
-33295
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::EndpointWithHostLabelOperationError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_with_media_type_test {
-+
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_media_type_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraitsWithMediaType")
             .method("POST")
             .header("Content-Type", "text/plain")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits_with_media_type(
                 move |input: crate::input::StreamingTraitsWithMediaTypeInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StreamingTraitsWithMediaTypeInput {
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(
                                     b"blobby blob blob",
                                 ),
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.foo,
                                 expected.foo,
                                 "Unexpected value for `foo`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.blob.collect().await.unwrap().into_bytes(),
                                 expected.blob.collect().await.unwrap().into_bytes()
                             );
                             let response = crate::output::StreamingTraitsWithMediaTypeOutput {
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                                 foo: ::std::option::Option::None,
                             };
                             response
                         };
                         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"
         );
-+
+    }
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonStreamingTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_media_type_with_blob_response() {
         let output = crate::output::StreamingTraitsWithMediaTypeOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b"blobby blob blob"),
         };
         use ::aws_smithy_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 = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
-33388
+    }
-33389
+}
-33390
 const CONTENT_TYPE_ENDPOINTOPERATION: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_STREAMINGTRAITSREQUIRELENGTH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EndpointOperationInput`](crate::input::EndpointOperationInput) using modelled bindings.
     pub struct EndpointOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EndpointOperationInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`StreamingTraitsRequireLengthInput`](crate::input::StreamingTraitsRequireLengthInput) using modelled bindings.
     pub struct StreamingTraitsRequireLengthInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsRequireLengthInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-33397
+    }
-33398
+}
-33399
 impl std::future::Future for EndpointOperationInputFuture {
 impl std::future::Future for StreamingTraitsRequireLengthInputFuture {
     type Output = Result<
         crate::input::EndpointOperationInput,
         crate::input::StreamingTraitsRequireLengthInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-33405
     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)
-33412
+    }
-33413
+}
-33414
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EndpointOperationInput
     > for crate::input::StreamingTraitsRequireLengthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33423
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33428
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EndpointOperationInputFuture;
     type Future = StreamingTraitsRequireLengthInputFuture;
-33431
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENDPOINTOPERATION,
                 &CONTENT_TYPE_STREAMINGTRAITSREQUIRELENGTH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33439
+            }
             crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
                 request,
--
+            )
             .await
             .map_err(Into::into)
             crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33450
+                )
             },
         );
         EndpointOperationInputFuture {
         StreamingTraitsRequireLengthInputFuture {
             inner: Box::pin(fut),
-33455
+        }
-33456
+    }
-33457
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EndpointOperationOutput
     > for crate::output::StreamingTraitsRequireLengthOutput
-33462
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_streaming_traits_require_length::ser_streaming_traits_require_length_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-33471
+    }
-33472
+}
-33473
 const CONTENT_TYPE_POSTUNIONWITHJSONNAME: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_require_length_test {
-+
     /// Serializes a blob in the HTTP payload with a required length
     /// Test ID: RestJsonStreamingTraitsRequireLengthWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_require_length_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraitsRequireLength")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits_require_length(
                 move |input: crate::input::StreamingTraitsRequireLengthInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StreamingTraitsRequireLengthInput {
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(
                                     b"blobby blob blob",
                                 ),
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.foo,
                                 expected.foo,
                                 "Unexpected value for `foo`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.blob.collect().await.unwrap().into_bytes(),
                                 expected.blob.collect().await.unwrap().into_bytes()
                             );
                             let response = crate::output::StreamingTraitsRequireLengthOutput {};
                             response
                         };
                         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"
         );
-+
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsRequireLengthWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_require_length_with_no_blob_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraitsRequireLength")
             .method("POST")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits_require_length(
                 move |input: crate::input::StreamingTraitsRequireLengthInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::StreamingTraitsRequireLengthInput {
                                 blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.foo,
                                 expected.foo,
                                 "Unexpected value for `foo`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.blob.collect().await.unwrap().into_bytes(),
                                 expected.blob.collect().await.unwrap().into_bytes()
                             );
                             let response = crate::output::StreamingTraitsRequireLengthOutput {};
                             response
                         };
                         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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_STREAMINGTRAITS: ::mime::Mime = ::mime::APPLICATION_OCTET_STREAM;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PostUnionWithJsonNameInput`](crate::input::PostUnionWithJsonNameInput) using modelled bindings.
     pub struct PostUnionWithJsonNameInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostUnionWithJsonNameInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`StreamingTraitsInput`](crate::input::StreamingTraitsInput) using modelled bindings.
     pub struct StreamingTraitsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-33595
+    }
-33596
+}
-33597
 impl std::future::Future for PostUnionWithJsonNameInputFuture {
 impl std::future::Future for StreamingTraitsInputFuture {
     type Output = Result<
         crate::input::PostUnionWithJsonNameInput,
         crate::input::StreamingTraitsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-33603
     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)
-33610
+    }
-33611
+}
-33612
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostUnionWithJsonNameInput
     > for crate::input::StreamingTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33621
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33626
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostUnionWithJsonNameInputFuture;
     type Future = StreamingTraitsInputFuture;
-33629
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_POSTUNIONWITHJSONNAME,
                 &CONTENT_TYPE_STREAMINGTRAITS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33637
+            }
             crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_streaming_traits::de_streaming_traits_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33648
+                )
             },
         );
         PostUnionWithJsonNameInputFuture {
         StreamingTraitsInputFuture {
             inner: Box::pin(fut),
-33653
+        }
-33654
+    }
-33655
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostUnionWithJsonNameOutput
     > for crate::output::StreamingTraitsOutput
-33660
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_post_union_with_json_name::ser_post_union_with_json_name_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_streaming_traits::ser_streaming_traits_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-33671
+    }
-33672
+}
-33673
 const CONTENT_TYPE_POSTPLAYERACTION: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod streaming_traits_test {
-+
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraits")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits(move |input: crate::input::StreamingTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::StreamingTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(
                                 b"blobby blob blob",
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.blob.collect().await.unwrap().into_bytes(),
                             expected.blob.collect().await.unwrap().into_bytes()
                         );
                         let response = crate::output::StreamingTraitsOutput {
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                             foo: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_no_blob_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StreamingTraits")
             .method("POST")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .streaming_traits(move |input: crate::input::StreamingTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::StreamingTraitsInput {
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.foo,
                             expected.foo,
                             "Unexpected value for `foo`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.blob.collect().await.unwrap().into_bytes(),
                             expected.blob.collect().await.unwrap().into_bytes()
                         );
                         let response = crate::output::StreamingTraitsOutput {
                             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
                             foo: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_blob_response() {
         let output = crate::output::StreamingTraitsOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b"blobby blob blob"),
         };
         use ::aws_smithy_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 = [
             ("Content-Type", "application/octet-stream"),
             ("X-Foo", "Foo"),
         ];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
-+
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonStreamingTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_streaming_traits_with_no_blob_body_response() {
         let output = crate::output::StreamingTraitsOutput {
             blob: ::aws_smithy_types::byte_stream::ByteStream::from_static(b""),
             foo: ::std::option::Option::Some("Foo".to_owned()),
         };
         use ::aws_smithy_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-Foo", "Foo")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_HTTPRESPONSECODE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`PostPlayerActionInput`](crate::input::PostPlayerActionInput) using modelled bindings.
     pub struct PostPlayerActionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::PostPlayerActionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpResponseCodeInput`](crate::input::HttpResponseCodeInput) using modelled bindings.
     pub struct HttpResponseCodeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpResponseCodeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-33855
+    }
-33856
+}
-33857
 impl std::future::Future for PostPlayerActionInputFuture {
 impl std::future::Future for HttpResponseCodeInputFuture {
     type Output = Result<
         crate::input::PostPlayerActionInput,
         crate::input::HttpResponseCodeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-33863
     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)
-33870
+    }
-33871
+}
-33872
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PostPlayerActionInput
     > for crate::input::HttpResponseCodeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33881
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-33885
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PostPlayerActionInputFuture;
     type Future = HttpResponseCodeInputFuture;
-33888
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_POSTPLAYERACTION,
                 &CONTENT_TYPE_HTTPRESPONSECODE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-33896
+            }
             crate::protocol_serde::shape_post_player_action::de_post_player_action_http_request(
             crate::protocol_serde::shape_http_response_code::de_http_response_code_http_request(
                 request,
-33899
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-33909
+                )
             },
         );
         PostPlayerActionInputFuture {
         HttpResponseCodeInputFuture {
             inner: Box::pin(fut),
-33914
+        }
-33915
+    }
-33916
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PostPlayerActionOutput
     > for crate::output::HttpResponseCodeOutput
-33921
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_post_player_action::ser_post_player_action_http_response(
         match crate::protocol_serde::shape_http_response_code::ser_http_response_code_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-33930
+            }
-33931
+        }
-33932
+    }
-33933
+}
-33934
 const CONTENT_TYPE_JSONUNIONS: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_response_code_test {
-+
     /// Binds the http response code to an output structure. Note that
     /// even though all members are bound outside of the payload, an
     /// empty JSON object is serialized in the response. However,
     /// clients should be able to handle an empty JSON object or an
     /// empty payload without failing to deserialize a response.
     /// Test ID: RestJsonHttpResponseCode
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_response_code_response() {
         let output = crate::output::HttpResponseCodeOutput {
             status: ::std::option::Option::Some(201),
         };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(201).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-+
+    }
     /// Binds the http response code to the http trait's code if the
     /// code isn't explicitly set. A client would be parsing the
     /// http response code, so this would always be present, but
     /// a server doesn't require it to be set to serialize a request.
     /// Test ID: RestJsonHttpResponseCodeDefaultsToModeledCode
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_response_code_defaults_to_modeled_code_response() {
         let output = crate::output::HttpResponseCodeOutput {
             status: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_HTTPPAYLOADWITHUNION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonUnionsInput`](crate::input::JsonUnionsInput) using modelled bindings.
     pub struct JsonUnionsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonUnionsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpPayloadWithUnionInput`](crate::input::HttpPayloadWithUnionInput) using modelled bindings.
     pub struct HttpPayloadWithUnionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithUnionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-34010
+    }
-34011
+}
-34012
 impl std::future::Future for JsonUnionsInputFuture {
 impl std::future::Future for HttpPayloadWithUnionInputFuture {
     type Output = Result<
         crate::input::JsonUnionsInput,
         crate::input::HttpPayloadWithUnionInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-34018
     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)
-34025
+    }
-34026
+}
-34027
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonUnionsInput
     > for crate::input::HttpPayloadWithUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34036
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34040
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonUnionsInputFuture;
     type Future = HttpPayloadWithUnionInputFuture;
-34043
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONUNIONS,
                 &CONTENT_TYPE_HTTPPAYLOADWITHUNION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-34051
+            }
             crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_http_payload_with_union::de_http_payload_with_union_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34062
+                )
             },
         );
         JsonUnionsInputFuture {
         HttpPayloadWithUnionInputFuture {
             inner: Box::pin(fut),
-34067
+        }
-34068
+    }
-34069
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonUnionsOutput
     > for crate::output::HttpPayloadWithUnionOutput
-34074
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_http_payload_with_union::ser_http_payload_with_union_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-34083
+    }
-34084
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonUnionsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_unions::ser_json_unions_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_union_test {
-+
     /// Serializes a union in the payload.
     /// Test ID: RestJsonHttpPayloadWithUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_union_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadWithUnion")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\n    \"greeting\": \"hello\"\n}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_with_union(move |input: crate::input::HttpPayloadWithUnionInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadWithUnionInput {
                             nested: ::std::option::Option::Some(
                                 crate::model::UnionPayload::Greeting("hello".to_owned()),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadWithUnionOutput {
                             nested: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// No payload is sent if the union has no value.
     /// Test ID: RestJsonHttpPayloadWithUnsetUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_unset_union_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadWithUnion")
             .method("PUT")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_with_union(move |input: crate::input::HttpPayloadWithUnionInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadWithUnionInput {
                             nested: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadWithUnionOutput {
                             nested: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes a union in the payload.
     /// Test ID: RestJsonHttpPayloadWithUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_union_response() {
         let output = crate::output::HttpPayloadWithUnionOutput {
             nested: ::std::option::Option::Some(crate::model::UnionPayload::Greeting(
                 "hello".to_owned(),
             )),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"greeting\": \"hello\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
     /// No payload is sent if the union has no value.
     /// Test ID: RestJsonHttpPayloadWithUnsetUnion
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_unset_union_response() {
         let output = crate::output::HttpPayloadWithUnionOutput {
             nested: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Length", "0")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
-34233
+    }
-34234
+}
-34235
 const CONTENT_TYPE_DOCUMENTTYPEASMAPVALUE: ::mime::Mime = ::mime::APPLICATION_JSON;
 static CONTENT_TYPE_HTTPSTRINGPAYLOAD: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DocumentTypeAsMapValueInput`](crate::input::DocumentTypeAsMapValueInput) using modelled bindings.
     pub struct DocumentTypeAsMapValueInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsMapValueInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpStringPayloadInput`](crate::input::HttpStringPayloadInput) using modelled bindings.
     pub struct HttpStringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpStringPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-34247
+    }
-34248
+}
-34249
 impl std::future::Future for DocumentTypeAsMapValueInputFuture {
 impl std::future::Future for HttpStringPayloadInputFuture {
     type Output = Result<
         crate::input::DocumentTypeAsMapValueInput,
         crate::input::HttpStringPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-34255
     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)
-34262
+    }
-34263
+}
-34264
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeAsMapValueInput
     > for crate::input::HttpStringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34273
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34277
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeAsMapValueInputFuture;
     type Future = HttpStringPayloadInputFuture;
-34280
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DOCUMENTTYPEASMAPVALUE,
                 &CONTENT_TYPE_HTTPSTRINGPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-34288
+            }
             crate::protocol_serde::shape_document_type_as_map_value::de_document_type_as_map_value_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_http_string_payload::de_http_string_payload_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34301
+                )
             },
         );
         DocumentTypeAsMapValueInputFuture {
         HttpStringPayloadInputFuture {
             inner: Box::pin(fut),
-34306
+        }
-34307
+    }
-34308
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeAsMapValueOutput
     > for crate::output::HttpStringPayloadOutput
-34313
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type_as_map_value::ser_document_type_as_map_value_http_response(self) {
         match crate::protocol_serde::shape_http_string_payload::ser_http_string_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-34320
+                        }
-34321
+                    }
-34322
+    }
-34323
+}
-34324
 const CONTENT_TYPE_DOCUMENTTYPEASPAYLOAD: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_string_payload_test {
-+
     /// Test ID: RestJsonStringPayloadRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_string_payload_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StringPayload")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("rawstring".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_string_payload(move |input: crate::input::HttpStringPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpStringPayloadInput {
                             payload: ::std::option::Option::Some("rawstring".to_owned()),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpStringPayloadOutput {
                             payload: ::std::option::Option::None,
                         };
                         response
                     };
                     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: RestJsonStringPayloadResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_string_payload_response_response() {
         let output = crate::output::HttpStringPayloadOutput {
             payload: ::std::option::Option::Some("rawstring".to_owned()),
         };
         use ::aws_smithy_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,
             "rawstring",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-+
+    }
-+
+}
-+
 static CONTENT_TYPE_HTTPENUMPAYLOAD: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DocumentTypeAsPayloadInput`](crate::input::DocumentTypeAsPayloadInput) using modelled bindings.
     pub struct DocumentTypeAsPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeAsPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpEnumPayloadInput`](crate::input::HttpEnumPayloadInput) using modelled bindings.
     pub struct HttpEnumPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEnumPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-34407
+    }
-34408
+}
-34409
 impl std::future::Future for DocumentTypeAsPayloadInputFuture {
 impl std::future::Future for HttpEnumPayloadInputFuture {
     type Output = Result<
         crate::input::DocumentTypeAsPayloadInput,
         crate::input::HttpEnumPayloadInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-34415
     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)
-34422
+    }
-34423
+}
-34424
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeAsPayloadInput
     > for crate::input::HttpEnumPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34433
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34437
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeAsPayloadInputFuture;
     type Future = HttpEnumPayloadInputFuture;
-34440
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DOCUMENTTYPEASPAYLOAD,
                 &CONTENT_TYPE_HTTPENUMPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-34448
+            }
             crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_http_enum_payload::de_http_enum_payload_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34461
+                )
             },
         );
         DocumentTypeAsPayloadInputFuture {
         HttpEnumPayloadInputFuture {
             inner: Box::pin(fut),
-34466
+        }
-34467
+    }
-34468
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeAsPayloadOutput
     > for crate::output::HttpEnumPayloadOutput
-34473
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type_as_payload::ser_document_type_as_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpEnumPayloadError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
-+
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_enum_payload_test {
-+
     /// Test ID: RestJsonEnumPayloadRequest
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_enum_payload_request_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EnumPayload")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("enumvalue".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_enum_payload(move |input: crate::input::HttpEnumPayloadInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpEnumPayloadInput {
                             payload: ::std::option::Option::Some(
                                 "enumvalue"
                                     .parse::<crate::model::StringEnum>()
                                     .expect("static value validated to member"),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpEnumPayloadOutput {
                             payload: ::std::option::Option::None,
                         };
                         Ok(response)
                     };
                     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: RestJsonEnumPayloadResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_enum_payload_response_response() {
         let output = crate::output::HttpEnumPayloadOutput {
             payload: ::std::option::Option::Some(
                 "enumvalue"
                     .parse::<crate::model::StringEnum>()
                     .expect("static value validated to member"),
             ),
         };
         use ::aws_smithy_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,
             "enumvalue",
             ::aws_smithy_protocol_test::MediaType::from("unknown"),
         ));
-34585
+    }
-34586
+}
-34587
 const CONTENT_TYPE_DOCUMENTTYPE: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_HTTPPAYLOADWITHSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`DocumentTypeInput`](crate::input::DocumentTypeInput) using modelled bindings.
     pub struct DocumentTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::DocumentTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpPayloadWithStructureInput`](crate::input::HttpPayloadWithStructureInput) using modelled bindings.
     pub struct HttpPayloadWithStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-34594
+    }
-34595
+}
-34596
 impl std::future::Future for DocumentTypeInputFuture {
 impl std::future::Future for HttpPayloadWithStructureInputFuture {
     type Output = Result<
         crate::input::DocumentTypeInput,
         crate::input::HttpPayloadWithStructureInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-34602
     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)
-34609
+    }
-34610
+}
-34611
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::DocumentTypeInput
     > for crate::input::HttpPayloadWithStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34620
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34624
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = DocumentTypeInputFuture;
     type Future = HttpPayloadWithStructureInputFuture;
-34627
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_DOCUMENTTYPE,
                 &CONTENT_TYPE_HTTPPAYLOADWITHSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-34635
+            }
             crate::protocol_serde::shape_document_type::de_document_type_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34646
+                )
             },
         );
         DocumentTypeInputFuture {
         HttpPayloadWithStructureInputFuture {
             inner: Box::pin(fut),
-34651
+        }
-34652
+    }
-34653
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::DocumentTypeOutput
     > for crate::output::HttpPayloadWithStructureOutput
-34658
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_document_type::ser_document_type_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_http_payload_with_structure::ser_http_payload_with_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-34667
+    }
-34668
+}
-34669
 const CONTENT_TYPE_JSONBLOBS: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_with_structure_test {
-+
     /// Serializes a structure in the payload
     /// Test ID: RestJsonHttpPayloadWithStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_structure_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadWithStructure")
             .method("PUT")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static(
                     "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}".as_bytes(),
                 ),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_with_structure(
                 move |input: crate::input::HttpPayloadWithStructureInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpPayloadWithStructureInput {
                                 nested: ::std::option::Option::Some(crate::model::NestedPayload {
                                     greeting: ::std::option::Option::Some("hello".to_owned()),
                                     name: ::std::option::Option::Some("Phreddy".to_owned()),
                                 }),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpPayloadWithStructureOutput {
                                 nested: ::std::option::Option::Some(crate::model::NestedPayload {
                                     greeting: ::std::option::Option::None,
                                     name: ::std::option::Option::None,
                                 }),
                             };
                             response
                         };
                         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"
         );
-+
+    }
     /// Serializes a structure in the payload
     /// Test ID: RestJsonHttpPayloadWithStructure
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_with_structure_response() {
         let output = crate::output::HttpPayloadWithStructureOutput {
             nested: ::std::option::Option::Some(crate::model::NestedPayload {
                 greeting: ::std::option::Option::Some("hello".to_owned()),
                 name: ::std::option::Option::Some("Phreddy".to_owned()),
             }),
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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,
             "{\n    \"greeting\": \"hello\",\n    \"name\": \"Phreddy\"\n}",
             ::aws_smithy_protocol_test::MediaType::from("application/json"),
         ));
-+
+    }
-+
+}
-+
 static CONTENT_TYPE_HTTPPAYLOADTRAITSWITHMEDIATYPE: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonBlobsInput`](crate::input::JsonBlobsInput) using modelled bindings.
     pub struct JsonBlobsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonBlobsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpPayloadTraitsWithMediaTypeInput`](crate::input::HttpPayloadTraitsWithMediaTypeInput) using modelled bindings.
     pub struct HttpPayloadTraitsWithMediaTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsWithMediaTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-34772
+    }
-34773
+}
-34774
 impl std::future::Future for JsonBlobsInputFuture {
 impl std::future::Future for HttpPayloadTraitsWithMediaTypeInputFuture {
     type Output = Result<
         crate::input::JsonBlobsInput,
         crate::input::HttpPayloadTraitsWithMediaTypeInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-34780
     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)
-34787
+    }
-34788
+}
-34789
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonBlobsInput
     > for crate::input::HttpPayloadTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34798
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34802
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonBlobsInputFuture;
     type Future = HttpPayloadTraitsWithMediaTypeInputFuture;
-34805
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONBLOBS,
                 &CONTENT_TYPE_HTTPPAYLOADTRAITSWITHMEDIATYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-34813
+            }
             crate::protocol_serde::shape_json_blobs::de_json_blobs_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_type_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34824
+                )
             },
         );
         JsonBlobsInputFuture {
         HttpPayloadTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
-34829
+        }
-34830
+    }
-34831
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonBlobsOutput
     > for crate::output::HttpPayloadTraitsWithMediaTypeOutput
-34836
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_blobs::ser_json_blobs_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_http_payload_traits_with_media_type::ser_http_payload_traits_with_media_type_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_traits_with_media_type_test {
-+
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_media_type_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraitsWithMediaType")
             .method("POST")
             .header("Content-Type", "text/plain")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits_with_media_type(
                 move |input: crate::input::HttpPayloadTraitsWithMediaTypeInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpPayloadTraitsWithMediaTypeInput {
                                 foo: ::std::option::Option::Some("Foo".to_owned()),
                                 blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                     "blobby blob blob",
                                 )),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpPayloadTraitsWithMediaTypeOutput {
                                 foo: ::std::option::Option::None,
                                 blob: ::std::option::Option::None,
                             };
                             response
                         };
                         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"
         );
-+
+    }
     /// Serializes a blob in the HTTP payload with a content-type
     /// Test ID: RestJsonHttpPayloadTraitsWithMediaTypeWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_media_type_with_blob_response() {
         let output = crate::output::HttpPayloadTraitsWithMediaTypeOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")),
         };
         use ::aws_smithy_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 = [("Content-Type", "text/plain"), ("X-Foo", "Foo")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
-34931
+    }
-34932
+}
-34933
 const CONTENT_TYPE_SPARSEJSONMAPS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SparseJsonMapsInput`](crate::input::SparseJsonMapsInput) using modelled bindings.
     pub struct SparseJsonMapsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonMapsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpPayloadTraitsInput`](crate::input::HttpPayloadTraitsInput) using modelled bindings.
     pub struct HttpPayloadTraitsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-34939
+    }
-34940
+}
-34941
 impl std::future::Future for SparseJsonMapsInputFuture {
 impl std::future::Future for HttpPayloadTraitsInputFuture {
     type Output = Result<
         crate::input::SparseJsonMapsInput,
         crate::input::HttpPayloadTraitsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-34947
     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)
-34954
+    }
-34955
+}
-34956
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SparseJsonMapsInput
     > for crate::input::HttpPayloadTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34965
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-34969
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SparseJsonMapsInputFuture;
     type Future = HttpPayloadTraitsInputFuture;
-34972
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSEJSONMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_sparse_json_maps::de_sparse_json_maps_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_http_payload_traits::de_http_payload_traits_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-34987
+                )
             },
         );
         SparseJsonMapsInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SparseJsonMapsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         HttpPayloadTraitsInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits::ser_http_payload_traits_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_payload_traits_test {
-+
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_blob_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("Content-Type", "application/octet-stream")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("blobby blob blob".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "blobby blob blob",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_no_blob_body_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Servers must accept any content type for blob inputs
     /// without the media type trait.
     /// Test ID: RestJsonHttpPayloadTraitsWithBlobAcceptsAllContentTypes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_blob_accepts_all_content_types_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("Content-Type", "image/jpeg")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("This is definitely a jpeg".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "This is definitely a jpeg",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Servers must accept any accept header for blob inputs
     /// without the media type trait.
     /// Test ID: RestJsonHttpPayloadTraitsWithBlobAcceptsAllAccepts
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_blob_accepts_all_accepts_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPayloadTraits")
             .method("POST")
             .header("Accept", "image/jpeg")
             .header("X-Foo", "Foo")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("This is definitely a jpeg".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_payload_traits(move |input: crate::input::HttpPayloadTraitsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPayloadTraitsInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new(
                                 "This is definitely a jpeg",
                             )),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPayloadTraitsOutput {
                             foo: ::std::option::Option::None,
                             blob: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Serializes a blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithBlob
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_blob_response() {
         let output = crate::output::HttpPayloadTraitsOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::std::option::Option::Some(::aws_smithy_types::Blob::new("blobby blob blob")),
         };
         use ::aws_smithy_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-Foo", "Foo")];
         ::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,
             "blobby blob blob",
             ::aws_smithy_protocol_test::MediaType::from("application/octet-stream"),
         ));
-35238
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::SparseJsonMapsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_error(&self)
--
+        {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Serializes an empty blob in the HTTP payload
     /// Test ID: RestJsonHttpPayloadTraitsWithNoBlobBody
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_payload_traits_with_no_blob_body_response() {
         let output = crate::output::HttpPayloadTraitsOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             blob: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Foo", "Foo")];
         ::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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
-35264
+    }
-35265
+}
-35266
 const CONTENT_TYPE_JSONMAPS: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_HTTPPREFIXHEADERSINRESPONSE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonMapsInput`](crate::input::JsonMapsInput) using modelled bindings.
     pub struct JsonMapsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonMapsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpPrefixHeadersInResponseInput`](crate::input::HttpPrefixHeadersInResponseInput) using modelled bindings.
     pub struct HttpPrefixHeadersInResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-35273
+    }
-35274
+}
-35275
 impl std::future::Future for JsonMapsInputFuture {
 impl std::future::Future for HttpPrefixHeadersInResponseInputFuture {
     type Output = Result<
         crate::input::JsonMapsInput,
         crate::input::HttpPrefixHeadersInResponseInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-35281
     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)
-35288
+    }
-35289
+}
-35290
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonMapsInput
     > for crate::input::HttpPrefixHeadersInResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35299
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35303
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonMapsInputFuture;
     type Future = HttpPrefixHeadersInResponseInputFuture;
-35306
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONMAPS,
                 &CONTENT_TYPE_HTTPPREFIXHEADERSINRESPONSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35314
+            }
             crate::protocol_serde::shape_json_maps::de_json_maps_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35325
+                )
             },
         );
         JsonMapsInputFuture {
         HttpPrefixHeadersInResponseInputFuture {
             inner: Box::pin(fut),
-35330
+        }
-35331
+    }
-35332
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonMapsOutput
     > for crate::output::HttpPrefixHeadersInResponseOutput
-35337
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_maps::ser_json_maps_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_http_prefix_headers_in_response::ser_http_prefix_headers_in_response_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-35346
+    }
-35347
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonMapsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_maps::ser_json_maps_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_prefix_headers_in_response_test {
-+
     /// (de)serializes all response headers
     /// Test ID: HttpPrefixHeadersResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn http_prefix_headers_response_response() {
         let output = crate::output::HttpPrefixHeadersInResponseOutput {
             prefix_headers: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert("X-Foo".to_owned().to_ascii_lowercase(), "Foo".to_owned());
                 ret.insert("Hello".to_owned().to_ascii_lowercase(), "Hello".to_owned());
                 ret
             }),
         };
         use ::aws_smithy_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 = [("Hello", "Hello"), ("X-Foo", "Foo")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-35377
+    }
-35378
+}
-35379
 const CONTENT_TYPE_SPARSEJSONLISTS: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_HTTPPREFIXHEADERS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SparseJsonListsInput`](crate::input::SparseJsonListsInput) using modelled bindings.
     pub struct SparseJsonListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SparseJsonListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpPrefixHeadersInput`](crate::input::HttpPrefixHeadersInput) using modelled bindings.
     pub struct HttpPrefixHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-35386
+    }
-35387
+}
-35388
 impl std::future::Future for SparseJsonListsInputFuture {
 impl std::future::Future for HttpPrefixHeadersInputFuture {
     type Output = Result<
         crate::input::SparseJsonListsInput,
         crate::input::HttpPrefixHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-35394
     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)
-35401
+    }
-35402
+}
-35403
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SparseJsonListsInput
     > for crate::input::HttpPrefixHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35412
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35416
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SparseJsonListsInputFuture;
     type Future = HttpPrefixHeadersInputFuture;
-35419
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSEJSONLISTS,
                 &CONTENT_TYPE_HTTPPREFIXHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35427
+            }
             crate::protocol_serde::shape_sparse_json_lists::de_sparse_json_lists_http_request(
             crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_http_request(
                 request,
-35430
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35440
+                )
             },
         );
         SparseJsonListsInputFuture {
         HttpPrefixHeadersInputFuture {
             inner: Box::pin(fut),
-35445
+        }
-35446
+    }
-35447
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SparseJsonListsOutput
     > for crate::output::HttpPrefixHeadersOutput
-35452
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_json_lists::ser_sparse_json_lists_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_JSONLISTS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonListsInput`](crate::input::JsonListsInput) using modelled bindings.
     pub struct JsonListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for JsonListsInputFuture {
     type Output = Result<
         crate::input::JsonListsInput,
         ::aws_smithy_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)
         match crate::protocol_serde::shape_http_prefix_headers::ser_http_prefix_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-35461
+    }
-35462
+}
-35463
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonListsInputFuture;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_prefix_headers_test {
-35467
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_json_lists::de_json_lists_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Adds headers by prefix
     /// Test ID: RestJsonHttpPrefixHeadersArePresent
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_prefix_headers_are_present_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpPrefixHeaders")
             .method("GET")
             .header("X-Foo", "Foo")
             .header("X-Foo-Abc", "Abc value")
             .header("X-Foo-Def", "Def value")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_prefix_headers(move |input: crate::input::HttpPrefixHeadersInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::HttpPrefixHeadersInput {
                             foo: ::std::option::Option::Some("Foo".to_owned()),
                             foo_map: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "Abc".to_owned().to_ascii_lowercase(),
                                     "Abc value".to_owned(),
                                 );
                                 ret.insert(
                                     "Def".to_owned().to_ascii_lowercase(),
                                     "Def value".to_owned(),
                                 );
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::HttpPrefixHeadersOutput {
                             foo: ::std::option::Option::None,
                             foo_map: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
         JsonListsInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonListsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_lists::ser_json_lists_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-35526
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonListsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_lists::ser_json_lists_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
     /// Adds headers by prefix
     /// Test ID: RestJsonHttpPrefixHeadersArePresent
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_prefix_headers_are_present_response() {
         let output = crate::output::HttpPrefixHeadersOutput {
             foo: ::std::option::Option::Some("Foo".to_owned()),
             foo_map: ::std::option::Option::Some({
                 let mut ret = ::std::collections::HashMap::new();
                 ret.insert(
                     "Abc".to_owned().to_ascii_lowercase(),
                     "Abc value".to_owned(),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_RECURSIVESHAPES: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`RecursiveShapesInput`](crate::input::RecursiveShapesInput) using modelled bindings.
     pub struct RecursiveShapesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::RecursiveShapesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for RecursiveShapesInputFuture {
     type Output = Result<
         crate::input::RecursiveShapesInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RecursiveShapesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RecursiveShapesInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RECURSIVESHAPES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_request(request)
                 .await
                 .map_err(Into::into)
                 ret.insert(
                     "Def".to_owned().to_ascii_lowercase(),
                     "Def value".to_owned(),
                 );
                 ret
             }),
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         RecursiveShapesInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RecursiveShapesOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         let expected_headers = [
             ("X-Foo", "Foo"),
             ("X-Foo-Abc", "Abc value"),
             ("X-Foo-Def", "Def value"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-35562
+    }
-35563
+}
-35564
 const CONTENT_TYPE_JSONINTENUMS: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_QUERYPARAMSASSTRINGLISTMAP: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonIntEnumsInput`](crate::input::JsonIntEnumsInput) using modelled bindings.
     pub struct JsonIntEnumsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonIntEnumsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`QueryParamsAsStringListMapInput`](crate::input::QueryParamsAsStringListMapInput) using modelled bindings.
     pub struct QueryParamsAsStringListMapInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryParamsAsStringListMapInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-35571
+    }
-35572
+}
-35573
 impl std::future::Future for JsonIntEnumsInputFuture {
 impl std::future::Future for QueryParamsAsStringListMapInputFuture {
     type Output = Result<
         crate::input::JsonIntEnumsInput,
         crate::input::QueryParamsAsStringListMapInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-35579
     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)
-35586
+    }
-35587
+}
-35588
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonIntEnumsInput
     > for crate::input::QueryParamsAsStringListMapInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35597
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35601
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonIntEnumsInputFuture;
     type Future = QueryParamsAsStringListMapInputFuture;
-35604
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONINTENUMS,
                 &CONTENT_TYPE_QUERYPARAMSASSTRINGLISTMAP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35612
+            }
             crate::protocol_serde::shape_json_int_enums::de_json_int_enums_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35623
+                )
             },
         );
         JsonIntEnumsInputFuture {
         QueryParamsAsStringListMapInputFuture {
             inner: Box::pin(fut),
-35628
+        }
-35629
+    }
-35630
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonIntEnumsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonIntEnumsError
     > for crate::output::QueryParamsAsStringListMapOutput
-35635
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_query_params_as_string_list_map::ser_query_params_as_string_list_map_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-35644
+    }
-35645
+}
-35646
 const CONTENT_TYPE_JSONENUMS: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod query_params_as_string_list_map_test {
-+
     /// Servers put all query params in map
     /// Test ID: RestJsonServersQueryParamsStringListMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_servers_query_params_string_list_map_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/StringListMap")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/StringListMap?corge=named&baz=bar&baz=qux"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .query_params_as_string_list_map(
                 move |input: crate::input::QueryParamsAsStringListMapInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::QueryParamsAsStringListMapInput {
                                 qux: ::std::option::Option::Some("named".to_owned()),
                                 foo: ::std::option::Option::Some({
                                     let mut ret = ::std::collections::HashMap::new();
                                     ret.insert("corge".to_owned(), vec!["named".to_owned()]);
                                     ret.insert(
                                         "baz".to_owned(),
                                         vec!["bar".to_owned(), "qux".to_owned()],
                                     );
                                     ret
                                 }),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::QueryParamsAsStringListMapOutput {};
                             response
                         };
                         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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_QUERYPRECEDENCE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonEnumsInput`](crate::input::JsonEnumsInput) using modelled bindings.
     pub struct JsonEnumsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonEnumsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-35714
+    }
-35715
+}
-35716
 impl std::future::Future for JsonEnumsInputFuture {
 impl std::future::Future for QueryPrecedenceInputFuture {
     type Output = Result<
         crate::input::JsonEnumsInput,
         crate::input::QueryPrecedenceInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-35722
     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)
-35729
+    }
-35730
+}
-35731
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonEnumsInput
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35740
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35744
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonEnumsInputFuture;
     type Future = QueryPrecedenceInputFuture;
-35747
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONENUMS,
                 &CONTENT_TYPE_QUERYPRECEDENCE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35755
+            }
             crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request)
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35766
+                )
             },
         );
         JsonEnumsInputFuture {
         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-35771
+        }
-35772
+    }
-35773
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonEnumsOutput
     > for crate::output::QueryPrecedenceOutput
-35778
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_response(self) {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-35787
+            }
-35788
+        }
-35789
+    }
-35790
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::JsonEnumsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_enums::ser_json_enums_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_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_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .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::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::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 response = crate::output::QueryPrecedenceOutput {};
                         response
                     };
                     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"
         );
-35843
+    }
-35844
+}
-35845
 const CONTENT_TYPE_JSONTIMESTAMPS: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_QUERYIDEMPOTENCYTOKENAUTOFILL: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`JsonTimestampsInput`](crate::input::JsonTimestampsInput) using modelled bindings.
     pub struct JsonTimestampsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::JsonTimestampsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`QueryIdempotencyTokenAutoFillInput`](crate::input::QueryIdempotencyTokenAutoFillInput) using modelled bindings.
     pub struct QueryIdempotencyTokenAutoFillInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryIdempotencyTokenAutoFillInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-35852
+    }
-35853
+}
-35854
 impl std::future::Future for JsonTimestampsInputFuture {
 impl std::future::Future for QueryIdempotencyTokenAutoFillInputFuture {
     type Output = Result<
         crate::input::JsonTimestampsInput,
         crate::input::QueryIdempotencyTokenAutoFillInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-35860
     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)
-35867
+    }
-35868
+}
-35869
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::JsonTimestampsInput
     > for crate::input::QueryIdempotencyTokenAutoFillInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35878
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35882
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = JsonTimestampsInputFuture;
     type Future = QueryIdempotencyTokenAutoFillInputFuture;
-35885
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_JSONTIMESTAMPS,
                 &CONTENT_TYPE_QUERYIDEMPOTENCYTOKENAUTOFILL,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35893
+            }
             crate::protocol_serde::shape_json_timestamps::de_json_timestamps_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35904
+                )
             },
         );
         JsonTimestampsInputFuture {
         QueryIdempotencyTokenAutoFillInputFuture {
             inner: Box::pin(fut),
-35909
+        }
-35910
+    }
-35911
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::JsonTimestampsOutput
     > for crate::output::QueryIdempotencyTokenAutoFillOutput
-35916
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_http_response(self)
--
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
         match crate::protocol_serde::shape_query_idempotency_token_auto_fill::ser_query_idempotency_token_auto_fill_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-35925
+    }
-35926
+}
-35927
 const CONTENT_TYPE_SIMPLESCALARPROPERTIES: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_OMITSSERIALIZINGEMPTYLISTS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SimpleScalarPropertiesInput`](crate::input::SimpleScalarPropertiesInput) using modelled bindings.
     pub struct SimpleScalarPropertiesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SimpleScalarPropertiesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`OmitsSerializingEmptyListsInput`](crate::input::OmitsSerializingEmptyListsInput) using modelled bindings.
     pub struct OmitsSerializingEmptyListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsSerializingEmptyListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-35934
+    }
-35935
+}
-35936
 impl std::future::Future for SimpleScalarPropertiesInputFuture {
 impl std::future::Future for OmitsSerializingEmptyListsInputFuture {
     type Output = Result<
         crate::input::SimpleScalarPropertiesInput,
         crate::input::OmitsSerializingEmptyListsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-35942
     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)
-35949
+    }
-35950
+}
-35951
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SimpleScalarPropertiesInput
     > for crate::input::OmitsSerializingEmptyListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-35960
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-35964
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
     type Future = OmitsSerializingEmptyListsInputFuture;
-35967
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
                 &CONTENT_TYPE_OMITSSERIALIZINGEMPTYLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-35975
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
             crate::protocol_serde::shape_omits_serializing_empty_lists::de_omits_serializing_empty_lists_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-35986
+                )
             },
         );
         SimpleScalarPropertiesInputFuture {
         OmitsSerializingEmptyListsInputFuture {
             inner: Box::pin(fut),
-35991
+        }
-35992
+    }
-35993
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SimpleScalarPropertiesOutput
     > for crate::output::OmitsSerializingEmptyListsOutput
-35998
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
         match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36005
+                        }
-36006
+                    }
-36007
+    }
-36008
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OmitsSerializingEmptyListsError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod omits_serializing_empty_lists_test {
-+
     /// Supports omitting empty lists.
     /// Test ID: RestJsonOmitsEmptyListQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn rest_json_omits_empty_list_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/OmitsSerializingEmptyLists")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .omits_serializing_empty_lists(
                 move |input: crate::input::OmitsSerializingEmptyListsInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::OmitsSerializingEmptyListsInput {
                                 query_string_list: ::std::option::Option::Some(vec![]),
                                 query_integer_list: ::std::option::Option::Some(vec![]),
                                 query_double_list: ::std::option::Option::Some(vec![]),
                                 query_boolean_list: ::std::option::Option::Some(vec![]),
                                 query_timestamp_list: ::std::option::Option::Some(vec![]),
                                 query_enum_list: ::std::option::Option::Some(vec![]),
                                 query_integer_enum_list: ::std::option::Option::Some(vec![]),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::OmitsSerializingEmptyListsOutput {};
                             Ok(response)
                         };
                         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"
         );
-+
+    }
-+
+}
-36083
 const CONTENT_TYPE_GREETINGWITHERRORS: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_OMITSNULLSERIALIZESEMPTYSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`GreetingWithErrorsInput`](crate::input::GreetingWithErrorsInput) using modelled bindings.
     pub struct GreetingWithErrorsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::GreetingWithErrorsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`OmitsNullSerializesEmptyStringInput`](crate::input::OmitsNullSerializesEmptyStringInput) using modelled bindings.
     pub struct OmitsNullSerializesEmptyStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsNullSerializesEmptyStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-36090
+    }
-36091
+}
-36092
 impl std::future::Future for GreetingWithErrorsInputFuture {
 impl std::future::Future for OmitsNullSerializesEmptyStringInputFuture {
     type Output = Result<
         crate::input::GreetingWithErrorsInput,
         crate::input::OmitsNullSerializesEmptyStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-36098
     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)
-36105
+    }
-36106
+}
-36107
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::GreetingWithErrorsInput
     > for crate::input::OmitsNullSerializesEmptyStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36116
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36120
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
     type Future = OmitsNullSerializesEmptyStringInputFuture;
-36123
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
                 &CONTENT_TYPE_OMITSNULLSERIALIZESEMPTYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36131
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
--
+            )
             .await
             .map_err(Into::into)
             crate::protocol_serde::shape_omits_null_serializes_empty_string::de_omits_null_serializes_empty_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36142
+                )
             },
         );
         GreetingWithErrorsInputFuture {
         OmitsNullSerializesEmptyStringInputFuture {
             inner: Box::pin(fut),
-36147
+        }
-36148
+    }
-36149
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::GreetingWithErrorsOutput
     > for crate::output::OmitsNullSerializesEmptyStringOutput
-36154
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
         match crate::protocol_serde::shape_omits_null_serializes_empty_string::ser_omits_null_serializes_empty_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36161
+                        }
-36162
+                    }
-36163
+    }
-36164
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::GreetingWithErrorsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod omits_null_serializes_empty_string_test {
-+
     /// Serializes empty query strings
     /// Test ID: RestJsonSerializesEmptyQueryValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_serializes_empty_query_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/OmitsNullSerializesEmptyString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/OmitsNullSerializesEmptyString?Empty=".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .omits_null_serializes_empty_string(
                 move |input: crate::input::OmitsNullSerializesEmptyStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::OmitsNullSerializesEmptyStringInput {
                                 empty_string: ::std::option::Option::Some("".to_owned()),
                                 null_value: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::OmitsNullSerializesEmptyStringOutput {};
                             response
                         };
                         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"
         );
-+
+    }
     /// Servers accept static query params as empty strings.
     /// Test ID: RestJsonServersAcceptStaticQueryParamAsEmptyString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_servers_accept_static_query_param_as_empty_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/OmitsNullSerializesEmptyString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/OmitsNullSerializesEmptyString?Empty".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .omits_null_serializes_empty_string(
                 move |input: crate::input::OmitsNullSerializesEmptyStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::OmitsNullSerializesEmptyStringInput {
                                 empty_string: ::std::option::Option::Some("".to_owned()),
                                 null_value: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::OmitsNullSerializesEmptyStringOutput {};
                             response
                         };
                         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"
         );
-36259
+    }
-36260
+}
-36261
 static CONTENT_TYPE_STREAMINGTRAITSWITHMEDIATYPE: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 const CONTENT_TYPE_IGNOREQUERYPARAMSINRESPONSE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StreamingTraitsWithMediaTypeInput`](crate::input::StreamingTraitsWithMediaTypeInput) using modelled bindings.
     pub struct StreamingTraitsWithMediaTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsWithMediaTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`IgnoreQueryParamsInResponseInput`](crate::input::IgnoreQueryParamsInResponseInput) using modelled bindings.
     pub struct IgnoreQueryParamsInResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::IgnoreQueryParamsInResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-36268
+    }
-36269
+}
-36270
 impl std::future::Future for StreamingTraitsWithMediaTypeInputFuture {
 impl std::future::Future for IgnoreQueryParamsInResponseInputFuture {
     type Output = Result<
         crate::input::StreamingTraitsWithMediaTypeInput,
         crate::input::IgnoreQueryParamsInResponseInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-36276
     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)
-36283
+    }
-36284
+}
-36285
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsWithMediaTypeInput
     > for crate::input::IgnoreQueryParamsInResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36294
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36298
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsWithMediaTypeInputFuture;
     type Future = IgnoreQueryParamsInResponseInputFuture;
-36301
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGTRAITSWITHMEDIATYPE,
                 &CONTENT_TYPE_IGNOREQUERYPARAMSINRESPONSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36309
+            }
             crate::protocol_serde::shape_streaming_traits_with_media_type::de_streaming_traits_with_media_type_http_request(request)
             crate::protocol_serde::shape_ignore_query_params_in_response::de_ignore_query_params_in_response_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36320
+                )
             },
         );
         StreamingTraitsWithMediaTypeInputFuture {
         IgnoreQueryParamsInResponseInputFuture {
             inner: Box::pin(fut),
-36325
+        }
-36326
+    }
-36327
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsWithMediaTypeOutput
     > for crate::output::IgnoreQueryParamsInResponseOutput
-36332
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits_with_media_type::ser_streaming_traits_with_media_type_http_response(self) {
         match crate::protocol_serde::shape_ignore_query_params_in_response::ser_ignore_query_params_in_response_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36339
+                        }
-36340
+                    }
-36341
+    }
-36342
+}
-36343
 const CONTENT_TYPE_STREAMINGTRAITSREQUIRELENGTH: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod ignore_query_params_in_response_test {
-+
     /// Query parameters must be ignored when serializing the output
     /// of an operation. As of January 2021, server implementations
     /// are expected to respond with a JSON object regardless of
     /// if the output parameters are empty.
     /// Test ID: RestJsonIgnoreQueryParamsInResponse
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_ignore_query_params_in_response_response() {
         let output = crate::output::IgnoreQueryParamsInResponseOutput {
             baz: ::std::option::Option::None,
         };
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_CONSTANTANDVARIABLEQUERYSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StreamingTraitsRequireLengthInput`](crate::input::StreamingTraitsRequireLengthInput) using modelled bindings.
     pub struct StreamingTraitsRequireLengthInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsRequireLengthInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`ConstantAndVariableQueryStringInput`](crate::input::ConstantAndVariableQueryStringInput) using modelled bindings.
     pub struct ConstantAndVariableQueryStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantAndVariableQueryStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-36387
+    }
-36388
+}
-36389
 impl std::future::Future for StreamingTraitsRequireLengthInputFuture {
 impl std::future::Future for ConstantAndVariableQueryStringInputFuture {
     type Output = Result<
         crate::input::StreamingTraitsRequireLengthInput,
         crate::input::ConstantAndVariableQueryStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-36395
     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)
-36402
+    }
-36403
+}
-36404
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsRequireLengthInput
     > for crate::input::ConstantAndVariableQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36413
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36417
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsRequireLengthInputFuture;
     type Future = ConstantAndVariableQueryStringInputFuture;
-36420
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGTRAITSREQUIRELENGTH,
                 &CONTENT_TYPE_CONSTANTANDVARIABLEQUERYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36428
+            }
             crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_http_request(request)
             crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36439
+                )
             },
         );
         StreamingTraitsRequireLengthInputFuture {
         ConstantAndVariableQueryStringInputFuture {
             inner: Box::pin(fut),
-36444
+        }
-36445
+    }
-36446
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsRequireLengthOutput
     > for crate::output::ConstantAndVariableQueryStringOutput
-36451
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits_require_length::ser_streaming_traits_require_length_http_response(self) {
         match crate::protocol_serde::shape_constant_and_variable_query_string::ser_constant_and_variable_query_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36458
+                        }
-36459
+                    }
-36460
+    }
-36461
+}
-36462
 const CONTENT_TYPE_STREAMINGTRAITS: ::mime::Mime = ::mime::APPLICATION_OCTET_STREAM;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod constant_and_variable_query_string_test {
-+
     /// Mixes constant and variable query string parameters
     /// Test ID: RestJsonConstantAndVariableQueryStringMissingOneValue
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_constant_and_variable_query_string_missing_one_value_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ConstantAndVariableQueryString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/ConstantAndVariableQueryString?foo=bar&baz=bam"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .constant_and_variable_query_string(
                 move |input: crate::input::ConstantAndVariableQueryStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::ConstantAndVariableQueryStringInput {
                                 baz: ::std::option::Option::Some("bam".to_owned()),
                                 maybe_set: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::ConstantAndVariableQueryStringOutput {};
                             response
                         };
                         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"
         );
-+
+    }
     /// Mixes constant and variable query string parameters
     /// Test ID: RestJsonConstantAndVariableQueryStringAllValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_constant_and_variable_query_string_all_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ConstantAndVariableQueryString")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/ConstantAndVariableQueryString?foo=bar&baz=bam&maybeSet=yes"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .constant_and_variable_query_string(
                 move |input: crate::input::ConstantAndVariableQueryStringInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::ConstantAndVariableQueryStringInput {
                                 baz: ::std::option::Option::Some("bam".to_owned()),
                                 maybe_set: ::std::option::Option::Some("yes".to_owned()),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::ConstantAndVariableQueryStringOutput {};
                             response
                         };
                         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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_CONSTANTQUERYSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`StreamingTraitsInput`](crate::input::StreamingTraitsInput) using modelled bindings.
     pub struct StreamingTraitsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingTraitsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`ConstantQueryStringInput`](crate::input::ConstantQueryStringInput) using modelled bindings.
     pub struct ConstantQueryStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantQueryStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-36569
+    }
-36570
+}
-36571
 impl std::future::Future for StreamingTraitsInputFuture {
 impl std::future::Future for ConstantQueryStringInputFuture {
     type Output = Result<
         crate::input::StreamingTraitsInput,
         crate::input::ConstantQueryStringInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-36577
     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)
-36584
+    }
-36585
+}
-36586
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StreamingTraitsInput
     > for crate::input::ConstantQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36595
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36599
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StreamingTraitsInputFuture;
     type Future = ConstantQueryStringInputFuture;
-36602
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STREAMINGTRAITS,
                 &CONTENT_TYPE_CONSTANTQUERYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36610
+            }
             crate::protocol_serde::shape_streaming_traits::de_streaming_traits_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_constant_query_string::de_constant_query_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-36621
+                )
             },
         );
         StreamingTraitsInputFuture {
         ConstantQueryStringInputFuture {
             inner: Box::pin(fut),
-36626
+        }
-36627
+    }
-36628
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StreamingTraitsOutput
     > for crate::output::ConstantQueryStringOutput
-36633
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_streaming_traits::ser_streaming_traits_http_response(
             self,
         ) {
             Ok(response) => response,
         match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ConstantQueryStringError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-36658
+            }
-36659
+        }
-36660
+    }
-36661
+}
-36662
 const CONTENT_TYPE_HTTPRESPONSECODE: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod constant_query_string_test {
-+
     /// Includes constant query string parameters
     /// Test ID: RestJsonConstantQueryString
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_constant_query_string_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ConstantQueryString/hi")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/ConstantQueryString/hi?foo=bar&hello".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .constant_query_string(move |input: crate::input::ConstantQueryStringInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::ConstantQueryStringInput {
                             hello: "hi".to_owned(),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::ConstantQueryStringOutput {};
                         Ok(response)
                     };
                     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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_ALLQUERYSTRINGTYPES: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpResponseCodeInput`](crate::input::HttpResponseCodeInput) using modelled bindings.
     pub struct HttpResponseCodeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpResponseCodeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`AllQueryStringTypesInput`](crate::input::AllQueryStringTypesInput) using modelled bindings.
     pub struct AllQueryStringTypesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::AllQueryStringTypesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-36717
+    }
-36718
+}
-36719
 impl std::future::Future for HttpResponseCodeInputFuture {
 impl std::future::Future for AllQueryStringTypesInputFuture {
     type Output = Result<
         crate::input::HttpResponseCodeInput,
         crate::input::AllQueryStringTypesInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-36725
     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)
-36732
+    }
-36733
+}
-36734
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpResponseCodeInput
     > for crate::input::AllQueryStringTypesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-36743
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-36747
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpResponseCodeInputFuture;
     type Future = AllQueryStringTypesInputFuture;
-36750
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPRESPONSECODE,
                 &CONTENT_TYPE_ALLQUERYSTRINGTYPES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-36758
+            }
             crate::protocol_serde::shape_http_response_code::de_http_response_code_http_request(
                 request,
--
+            )
             crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+                )
             },
         );
         AllQueryStringTypesInputFuture {
             inner: Box::pin(fut),
-+
+        }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::AllQueryStringTypesOutput
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::AllQueryStringTypesError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod all_query_string_types_test {
-+
     /// Serializes query string parameters with all supported types
     /// Test ID: RestJsonAllQueryStringTypes
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_all_query_string_types_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?String=Hello%20there&StringList=a&StringList=b&StringList=c&StringSet=a&StringSet=b&StringSet=c&Byte=1&Short=2&Integer=3&IntegerList=1&IntegerList=2&IntegerList=3&IntegerSet=1&IntegerSet=2&IntegerSet=3&Long=4&Float=1.1&Double=1.1&DoubleList=1.1&DoubleList=2.1&DoubleList=3.1&Boolean=true&BooleanList=true&BooleanList=false&BooleanList=true&Timestamp=1970-01-01T00%3A00%3A01Z&TimestampList=1970-01-01T00%3A00%3A01Z&TimestampList=1970-01-01T00%3A00%3A02Z&TimestampList=1970-01-01T00%3A00%3A03Z&Enum=Foo&EnumList=Foo&EnumList=Baz&EnumList=Bar&IntegerEnum=1&IntegerEnumList=1&IntegerEnumList=2&IntegerEnumList=3".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_string: ::std::option::Option::Some("Hello there".to_owned()),
                             query_string_list: ::std::option::Option::Some(vec![
                                 "a".to_owned(),
                                 "b".to_owned(),
                                 "c".to_owned(),
                             ]),
                             query_string_set: ::std::option::Option::Some(
                                 vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]
                                     .try_into()
                                     .expect("this is only used in tests"),
                             ),
                             query_byte: ::std::option::Option::Some(1),
                             query_short: ::std::option::Option::Some(2),
                             query_integer: ::std::option::Option::Some(3),
                             query_integer_list: ::std::option::Option::Some(vec![1, 2, 3]),
                             query_integer_set: ::std::option::Option::Some(
                                 vec![1, 2, 3]
                                     .try_into()
                                     .expect("this is only used in tests"),
                             ),
                             query_long: ::std::option::Option::Some(4),
                             query_float: ::std::option::Option::Some(1.1_f32),
                             query_double: ::std::option::Option::Some(1.1_f64),
                             query_double_list: ::std::option::Option::Some(vec![
 .1_f64, 2.1_f64, 3.1_f64,
                             ]),
                             query_boolean: ::std::option::Option::Some(true),
                             query_boolean_list: ::std::option::Option::Some(vec![
                                 true, false, true,
                             ]),
                             query_timestamp: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64),
                             ),
                             query_timestamp_list: ::std::option::Option::Some(vec![
                                 ::aws_smithy_types::DateTime::from_fractional_secs(1, 0_f64),
                                 ::aws_smithy_types::DateTime::from_fractional_secs(2, 0_f64),
                                 ::aws_smithy_types::DateTime::from_fractional_secs(3, 0_f64),
                             ]),
                             query_enum: ::std::option::Option::Some(
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ),
                             query_enum_list: ::std::option::Option::Some(vec![
                                 "Foo"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "Baz"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                                 "Bar"
                                     .parse::<crate::model::FooEnum>()
                                     .expect("static value validated to member"),
                             ]),
                             query_integer_enum: ::std::option::Option::Some(1),
                             query_integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("String".to_owned(), vec!["Hello there".to_owned()]);
                                 ret.insert(
                                     "StringList".to_owned(),
                                     vec!["a".to_owned(), "b".to_owned(), "c".to_owned()],
                                 );
                                 ret.insert(
                                     "StringSet".to_owned(),
                                     vec!["a".to_owned(), "b".to_owned(), "c".to_owned()],
                                 );
                                 ret.insert("Byte".to_owned(), vec!["1".to_owned()]);
                                 ret.insert("Short".to_owned(), vec!["2".to_owned()]);
                                 ret.insert("Integer".to_owned(), vec!["3".to_owned()]);
                                 ret.insert(
                                     "IntegerList".to_owned(),
                                     vec!["1".to_owned(), "2".to_owned(), "3".to_owned()],
                                 );
                                 ret.insert(
                                     "IntegerSet".to_owned(),
                                     vec!["1".to_owned(), "2".to_owned(), "3".to_owned()],
                                 );
                                 ret.insert("Long".to_owned(), vec!["4".to_owned()]);
                                 ret.insert("Float".to_owned(), vec!["1.1".to_owned()]);
                                 ret.insert("Double".to_owned(), vec!["1.1".to_owned()]);
                                 ret.insert(
                                     "DoubleList".to_owned(),
                                     vec!["1.1".to_owned(), "2.1".to_owned(), "3.1".to_owned()],
                                 );
                                 ret.insert("Boolean".to_owned(), vec!["true".to_owned()]);
                                 ret.insert(
                                     "BooleanList".to_owned(),
                                     vec!["true".to_owned(), "false".to_owned(), "true".to_owned()],
                                 );
                                 ret.insert(
                                     "Timestamp".to_owned(),
                                     vec!["1970-01-01T00:00:01Z".to_owned()],
                                 );
                                 ret.insert(
                                     "TimestampList".to_owned(),
                                     vec![
                                         "1970-01-01T00:00:01Z".to_owned(),
                                         "1970-01-01T00:00:02Z".to_owned(),
                                         "1970-01-01T00:00:03Z".to_owned(),
                                     ],
                                 );
                                 ret.insert("Enum".to_owned(), vec!["Foo".to_owned()]);
                                 ret.insert(
                                     "EnumList".to_owned(),
                                     vec!["Foo".to_owned(), "Baz".to_owned(), "Bar".to_owned()],
                                 );
                                 ret.insert("IntegerEnum".to_owned(), vec!["1".to_owned()]);
                                 ret.insert(
                                     "IntegerEnumList".to_owned(),
                                     vec!["1".to_owned(), "2".to_owned(), "3".to_owned()],
                                 );
                                 ret
                             }),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-+
+                }
             })
             .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
             .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"
         );
         HttpResponseCodeInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpResponseCodeOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_response_code::ser_http_response_code_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPPAYLOADWITHUNION: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadWithUnionInput`](crate::input::HttpPayloadWithUnionInput) using modelled bindings.
     pub struct HttpPayloadWithUnionInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithUnionInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpPayloadWithUnionInputFuture {
     type Output = Result<
         crate::input::HttpPayloadWithUnionInput,
         ::aws_smithy_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)
-37076
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadWithUnionInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadWithUnionInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPAYLOADWITHUNION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_payload_with_union::de_http_payload_with_union_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Handles query string maps
     /// Test ID: RestJsonQueryStringMap
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_query_string_map_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() =
             "/AllQueryStringTypesInput?QueryParamsStringKeyA=Foo&QueryParamsStringKeyB=Bar"
                 .parse()
                 .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "QueryParamsStringKeyA".to_owned(),
                                     vec!["Foo".to_owned()],
                                 );
                                 ret.insert(
                                     "QueryParamsStringKeyB".to_owned(),
                                     vec!["Bar".to_owned()],
                                 );
                                 ret
                             }),
                             query_string: ::std::option::Option::None,
                             query_string_list: ::std::option::Option::None,
                             query_string_set: ::std::option::Option::None,
                             query_byte: ::std::option::Option::None,
                             query_short: ::std::option::Option::None,
                             query_integer: ::std::option::Option::None,
                             query_integer_list: ::std::option::Option::None,
                             query_integer_set: ::std::option::Option::None,
                             query_long: ::std::option::Option::None,
                             query_float: ::std::option::Option::None,
                             query_double: ::std::option::Option::None,
                             query_double_list: ::std::option::Option::None,
                             query_boolean: ::std::option::Option::None,
                             query_boolean_list: ::std::option::Option::None,
                             query_timestamp: ::std::option::Option::None,
                             query_timestamp_list: ::std::option::Option::None,
                             query_enum: ::std::option::Option::None,
                             query_enum_list: ::std::option::Option::None,
                             query_integer_enum: ::std::option::Option::None,
                             query_integer_enum_list: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                     };
                     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"
         );
         HttpPayloadWithUnionInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadWithUnionOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_with_union::ser_http_payload_with_union_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 static CONTENT_TYPE_HTTPSTRINGPAYLOAD: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpStringPayloadInput`](crate::input::HttpStringPayloadInput) using modelled bindings.
     pub struct HttpStringPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpStringPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpStringPayloadInputFuture {
     type Output = Result<
         crate::input::HttpStringPayloadInput,
         ::aws_smithy_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)
-37259
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpStringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpStringPayloadInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPSTRINGPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_string_payload::de_http_string_payload_http_request(
                 request,
--
+            )
     /// Handles escaping all required characters in the query string.
     /// Test ID: RestJsonQueryStringEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_query_string_escaping_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?String=%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9".parse().unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_string: ::std::option::Option::Some(
                                 " %:/?#[]@!$&'()*+,;=😹".to_owned(),
                             ),
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert(
                                     "String".to_owned(),
                                     vec![" %:/?#[]@!$&'()*+,;=😹".to_owned()],
                                 );
                                 ret
                             }),
                             query_string_list: ::std::option::Option::None,
                             query_string_set: ::std::option::Option::None,
                             query_byte: ::std::option::Option::None,
                             query_short: ::std::option::Option::None,
                             query_integer: ::std::option::Option::None,
                             query_integer_list: ::std::option::Option::None,
                             query_integer_set: ::std::option::Option::None,
                             query_long: ::std::option::Option::None,
                             query_float: ::std::option::Option::None,
                             query_double: ::std::option::Option::None,
                             query_double_list: ::std::option::Option::None,
                             query_boolean: ::std::option::Option::None,
                             query_boolean_list: ::std::option::Option::None,
                             query_timestamp: ::std::option::Option::None,
                             query_timestamp_list: ::std::option::Option::None,
                             query_enum: ::std::option::Option::None,
                             query_enum_list: ::std::option::Option::None,
                             query_integer_enum: ::std::option::Option::None,
                             query_integer_enum_list: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                     };
                     sender.send(()).await.expect("receiver dropped early");
                     result
-+
+                }
             })
             .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
             .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"
         );
         HttpStringPayloadInputFuture {
             inner: Box::pin(fut),
--
+        }
-37437
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpStringPayloadOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_string_payload::ser_http_string_payload_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
     /// Supports handling NaN float query values.
     /// Test ID: RestJsonSupportsNaNFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Float=NaN&Double=NaN"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::AllQueryStringTypesInput {
                 query_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 query_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 query_params_map_of_string_list:
                     ::std::option::Option::Some(
-+
+                         {
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "Float".to_owned()
-+
+                                ,
                                 vec![
                                     "NaN".to_owned()
-+
+                                    ,
-+
+                                ]
                             );
                             ret.insert(
                                 "Double".to_owned()
-+
+                                ,
                                 vec![
                                     "NaN".to_owned()
-+
+                                    ,
-+
+                                ]
                             );
                             ret
-37495
+                        }
--
+                    }
--
+    }
--
+}
--
 static CONTENT_TYPE_HTTPENUMPAYLOAD: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpEnumPayloadInput`](crate::input::HttpEnumPayloadInput) using modelled bindings.
     pub struct HttpEnumPayloadInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpEnumPayloadInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpEnumPayloadInputFuture {
     type Output = Result<
         crate::input::HttpEnumPayloadInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpEnumPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpEnumPayloadInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPENUMPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_enum_payload::de_http_enum_payload_http_request(
                 request,
--
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         );
         HttpEnumPayloadInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpEnumPayloadOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpEnumPayloadError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_error(
             &self,
         ) {
             Ok(mut response) => {
                 response.extensions_mut().insert(
                     ::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()),
                 );
                 response
--
+            }
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                    )
-+
+                ,
                 query_string:
                     ::std::option::Option::None
-+
+                ,
                 query_string_list:
                     ::std::option::Option::None
-+
+                ,
                 query_string_set:
                     ::std::option::Option::None
-+
+                ,
                 query_byte:
                     ::std::option::Option::None
-+
+                ,
                 query_short:
                     ::std::option::Option::None
-+
+                ,
                 query_integer:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_set:
                     ::std::option::Option::None
-+
+                ,
                 query_long:
                     ::std::option::Option::None
-+
+                ,
                 query_double_list:
                     ::std::option::Option::None
-+
+                ,
                 query_boolean:
                     ::std::option::Option::None
-+
+                ,
                 query_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 query_timestamp:
                     ::std::option::Option::None
-+
+                ,
                 query_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 query_enum:
                     ::std::option::Option::None
-+
+                ,
                 query_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-37552
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPPAYLOADWITHSTRUCTURE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadWithStructureInput`](crate::input::HttpPayloadWithStructureInput) using modelled bindings.
     pub struct HttpPayloadWithStructureInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadWithStructureInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpPayloadWithStructureInputFuture {
     type Output = Result<
         crate::input::HttpPayloadWithStructureInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadWithStructureInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadWithStructureInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPAYLOADWITHSTRUCTURE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+        ;
         ::pretty_assertions::assert_eq!(input.query_string, expected.query_string, "Unexpected value for `query_string`");
         ::pretty_assertions::assert_eq!(input.query_string_list, expected.query_string_list, "Unexpected value for `query_string_list`");
         ::pretty_assertions::assert_eq!(input.query_string_set, expected.query_string_set, "Unexpected value for `query_string_set`");
         ::pretty_assertions::assert_eq!(input.query_byte, expected.query_byte, "Unexpected value for `query_byte`");
         ::pretty_assertions::assert_eq!(input.query_short, expected.query_short, "Unexpected value for `query_short`");
         ::pretty_assertions::assert_eq!(input.query_integer, expected.query_integer, "Unexpected value for `query_integer`");
         ::pretty_assertions::assert_eq!(input.query_integer_list, expected.query_integer_list, "Unexpected value for `query_integer_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_set, expected.query_integer_set, "Unexpected value for `query_integer_set`");
         ::pretty_assertions::assert_eq!(input.query_long, expected.query_long, "Unexpected value for `query_long`");
         assert!(input.query_float.float_equals(&expected.query_float),
                                             "Unexpected value for `query_float` {:?} vs. {:?}", expected.query_float, input.query_float);
         assert!(input.query_double.float_equals(&expected.query_double),
                                             "Unexpected value for `query_double` {:?} vs. {:?}", expected.query_double, input.query_double);
         ::pretty_assertions::assert_eq!(input.query_double_list, expected.query_double_list, "Unexpected value for `query_double_list`");
         ::pretty_assertions::assert_eq!(input.query_boolean, expected.query_boolean, "Unexpected value for `query_boolean`");
         ::pretty_assertions::assert_eq!(input.query_boolean_list, expected.query_boolean_list, "Unexpected value for `query_boolean_list`");
         ::pretty_assertions::assert_eq!(input.query_timestamp, expected.query_timestamp, "Unexpected value for `query_timestamp`");
         ::pretty_assertions::assert_eq!(input.query_timestamp_list, expected.query_timestamp_list, "Unexpected value for `query_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.query_enum, expected.query_enum, "Unexpected value for `query_enum`");
         ::pretty_assertions::assert_eq!(input.query_enum_list, expected.query_enum_list, "Unexpected value for `query_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum, expected.query_integer_enum, "Unexpected value for `query_integer_enum`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum_list, expected.query_integer_enum_list, "Unexpected value for `query_integer_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_params_map_of_string_list, expected.query_params_map_of_string_list, "Unexpected value for `query_params_map_of_string_list`");
         let response =
             crate::output::AllQueryStringTypesOutput {
-37579
+            }
             crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_structure_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
-+
+        ;
         Ok(response) };
                                 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"
         );
         HttpPayloadWithStructureInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadWithStructureOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_with_structure::ser_http_payload_with_structure_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 static CONTENT_TYPE_HTTPPAYLOADTRAITSWITHMEDIATYPE: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "text/plain"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadTraitsWithMediaTypeInput`](crate::input::HttpPayloadTraitsWithMediaTypeInput) using modelled bindings.
     pub struct HttpPayloadTraitsWithMediaTypeInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsWithMediaTypeInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-37594
+    }
--
+}
--
 impl std::future::Future for HttpPayloadTraitsWithMediaTypeInputFuture {
     type Output = Result<
         crate::input::HttpPayloadTraitsWithMediaTypeInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraitsWithMediaTypeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraitsWithMediaTypeInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPAYLOADTRAITSWITHMEDIATYPE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
     /// Supports handling Infinity float query values.
     /// Test ID: RestJsonSupportsInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Float=Infinity&Double=Infinity"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::AllQueryStringTypesInput {
                 query_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 query_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 query_params_map_of_string_list:
                     ::std::option::Option::Some(
-+
+                         {
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "Float".to_owned()
-+
+                                ,
                                 vec![
                                     "Infinity".to_owned()
-+
+                                    ,
-+
+                                ]
                             );
                             ret.insert(
                                 "Double".to_owned()
-+
+                                ,
                                 vec![
                                     "Infinity".to_owned()
-+
+                                    ,
-+
+                                ]
                             );
                             ret
-+
+                        }
-+
+                    )
-+
+                ,
                 query_string:
                     ::std::option::Option::None
-+
+                ,
                 query_string_list:
                     ::std::option::Option::None
-+
+                ,
                 query_string_set:
                     ::std::option::Option::None
-+
+                ,
                 query_byte:
                     ::std::option::Option::None
-+
+                ,
                 query_short:
                     ::std::option::Option::None
-+
+                ,
                 query_integer:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_set:
                     ::std::option::Option::None
-+
+                ,
                 query_long:
                     ::std::option::Option::None
-+
+                ,
                 query_double_list:
                     ::std::option::Option::None
-+
+                ,
                 query_boolean:
                     ::std::option::Option::None
-+
+                ,
                 query_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 query_timestamp:
                     ::std::option::Option::None
-+
+                ,
                 query_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 query_enum:
                     ::std::option::Option::None
-+
+                ,
                 query_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-37709
+            }
             crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_type_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
-+
+        ;
         ::pretty_assertions::assert_eq!(input.query_string, expected.query_string, "Unexpected value for `query_string`");
         ::pretty_assertions::assert_eq!(input.query_string_list, expected.query_string_list, "Unexpected value for `query_string_list`");
         ::pretty_assertions::assert_eq!(input.query_string_set, expected.query_string_set, "Unexpected value for `query_string_set`");
         ::pretty_assertions::assert_eq!(input.query_byte, expected.query_byte, "Unexpected value for `query_byte`");
         ::pretty_assertions::assert_eq!(input.query_short, expected.query_short, "Unexpected value for `query_short`");
         ::pretty_assertions::assert_eq!(input.query_integer, expected.query_integer, "Unexpected value for `query_integer`");
         ::pretty_assertions::assert_eq!(input.query_integer_list, expected.query_integer_list, "Unexpected value for `query_integer_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_set, expected.query_integer_set, "Unexpected value for `query_integer_set`");
         ::pretty_assertions::assert_eq!(input.query_long, expected.query_long, "Unexpected value for `query_long`");
         assert!(input.query_float.float_equals(&expected.query_float),
                                             "Unexpected value for `query_float` {:?} vs. {:?}", expected.query_float, input.query_float);
         assert!(input.query_double.float_equals(&expected.query_double),
                                             "Unexpected value for `query_double` {:?} vs. {:?}", expected.query_double, input.query_double);
         ::pretty_assertions::assert_eq!(input.query_double_list, expected.query_double_list, "Unexpected value for `query_double_list`");
         ::pretty_assertions::assert_eq!(input.query_boolean, expected.query_boolean, "Unexpected value for `query_boolean`");
         ::pretty_assertions::assert_eq!(input.query_boolean_list, expected.query_boolean_list, "Unexpected value for `query_boolean_list`");
         ::pretty_assertions::assert_eq!(input.query_timestamp, expected.query_timestamp, "Unexpected value for `query_timestamp`");
         ::pretty_assertions::assert_eq!(input.query_timestamp_list, expected.query_timestamp_list, "Unexpected value for `query_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.query_enum, expected.query_enum, "Unexpected value for `query_enum`");
         ::pretty_assertions::assert_eq!(input.query_enum_list, expected.query_enum_list, "Unexpected value for `query_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum, expected.query_integer_enum, "Unexpected value for `query_integer_enum`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum_list, expected.query_integer_enum_list, "Unexpected value for `query_integer_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_params_map_of_string_list, expected.query_params_map_of_string_list, "Unexpected value for `query_params_map_of_string_list`");
         let response =
             crate::output::AllQueryStringTypesOutput {
-+
+            }
-+
+        ;
         Ok(response) };
                                 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"
         );
         HttpPayloadTraitsWithMediaTypeInputFuture {
             inner: Box::pin(fut),
--
+        }
-37751
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsWithMediaTypeOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits_with_media_type::ser_http_payload_traits_with_media_type_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
     /// Supports handling -Infinity float query values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Float=-Infinity&Double=-Infinity"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::AllQueryStringTypesInput {
                 query_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 query_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 query_params_map_of_string_list:
                     ::std::option::Option::Some(
-+
+                         {
                             let mut ret = ::std::collections::HashMap::new();
                             ret.insert(
                                 "Float".to_owned()
-+
+                                ,
                                 vec![
                                     "-Infinity".to_owned()
-+
+                                    ,
-+
+                                ]
                             );
                             ret.insert(
                                 "Double".to_owned()
-+
+                                ,
                                 vec![
                                     "-Infinity".to_owned()
-+
+                                    ,
-+
+                                ]
                             );
                             ret
-37809
+                        }
--
+                    }
--
+    }
--
+}
--
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPayloadTraitsInput`](crate::input::HttpPayloadTraitsInput) using modelled bindings.
     pub struct HttpPayloadTraitsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPayloadTraitsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpPayloadTraitsInputFuture {
     type Output = Result<
         crate::input::HttpPayloadTraitsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPayloadTraitsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPayloadTraitsInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_http_payload_traits::de_http_payload_traits_http_request(
                 request,
--
+            )
-+
+                    )
-+
+                ,
                 query_string:
                     ::std::option::Option::None
-+
+                ,
                 query_string_list:
                     ::std::option::Option::None
-+
+                ,
                 query_string_set:
                     ::std::option::Option::None
-+
+                ,
                 query_byte:
                     ::std::option::Option::None
-+
+                ,
                 query_short:
                     ::std::option::Option::None
-+
+                ,
                 query_integer:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_set:
                     ::std::option::Option::None
-+
+                ,
                 query_long:
                     ::std::option::Option::None
-+
+                ,
                 query_double_list:
                     ::std::option::Option::None
-+
+                ,
                 query_boolean:
                     ::std::option::Option::None
-+
+                ,
                 query_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 query_timestamp:
                     ::std::option::Option::None
-+
+                ,
                 query_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 query_enum:
                     ::std::option::Option::None
-+
+                ,
                 query_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 query_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-+
+            }
-+
+        ;
         ::pretty_assertions::assert_eq!(input.query_string, expected.query_string, "Unexpected value for `query_string`");
         ::pretty_assertions::assert_eq!(input.query_string_list, expected.query_string_list, "Unexpected value for `query_string_list`");
         ::pretty_assertions::assert_eq!(input.query_string_set, expected.query_string_set, "Unexpected value for `query_string_set`");
         ::pretty_assertions::assert_eq!(input.query_byte, expected.query_byte, "Unexpected value for `query_byte`");
         ::pretty_assertions::assert_eq!(input.query_short, expected.query_short, "Unexpected value for `query_short`");
         ::pretty_assertions::assert_eq!(input.query_integer, expected.query_integer, "Unexpected value for `query_integer`");
         ::pretty_assertions::assert_eq!(input.query_integer_list, expected.query_integer_list, "Unexpected value for `query_integer_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_set, expected.query_integer_set, "Unexpected value for `query_integer_set`");
         ::pretty_assertions::assert_eq!(input.query_long, expected.query_long, "Unexpected value for `query_long`");
         assert!(input.query_float.float_equals(&expected.query_float),
                                             "Unexpected value for `query_float` {:?} vs. {:?}", expected.query_float, input.query_float);
         assert!(input.query_double.float_equals(&expected.query_double),
                                             "Unexpected value for `query_double` {:?} vs. {:?}", expected.query_double, input.query_double);
         ::pretty_assertions::assert_eq!(input.query_double_list, expected.query_double_list, "Unexpected value for `query_double_list`");
         ::pretty_assertions::assert_eq!(input.query_boolean, expected.query_boolean, "Unexpected value for `query_boolean`");
         ::pretty_assertions::assert_eq!(input.query_boolean_list, expected.query_boolean_list, "Unexpected value for `query_boolean_list`");
         ::pretty_assertions::assert_eq!(input.query_timestamp, expected.query_timestamp, "Unexpected value for `query_timestamp`");
         ::pretty_assertions::assert_eq!(input.query_timestamp_list, expected.query_timestamp_list, "Unexpected value for `query_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.query_enum, expected.query_enum, "Unexpected value for `query_enum`");
         ::pretty_assertions::assert_eq!(input.query_enum_list, expected.query_enum_list, "Unexpected value for `query_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum, expected.query_integer_enum, "Unexpected value for `query_integer_enum`");
         ::pretty_assertions::assert_eq!(input.query_integer_enum_list, expected.query_integer_enum_list, "Unexpected value for `query_integer_enum_list`");
         ::pretty_assertions::assert_eq!(input.query_params_map_of_string_list, expected.query_params_map_of_string_list, "Unexpected value for `query_params_map_of_string_list`");
         let response =
             crate::output::AllQueryStringTypesOutput {
-+
+            }
-+
+        ;
         Ok(response) };
                                 sender.send(()).await.expect("receiver dropped early");
                                 result
-+
+                            }
                         })
                         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
             .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"
         );
         HttpPayloadTraitsInputFuture {
             inner: Box::pin(fut),
--
+        }
-37908
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPayloadTraitsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_payload_traits::ser_http_payload_traits_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Query values of 0 and false are serialized
     /// Test ID: RestJsonZeroAndFalseQueryValues
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_zero_and_false_query_values_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/AllQueryStringTypesInput")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         *http_request.uri_mut() = "/AllQueryStringTypesInput?Integer=0&Boolean=false"
             .parse()
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .all_query_string_types(move |input: crate::input::AllQueryStringTypesInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::AllQueryStringTypesInput {
                             query_integer: ::std::option::Option::Some(0),
                             query_boolean: ::std::option::Option::Some(false),
                             query_params_map_of_string_list: ::std::option::Option::Some({
                                 let mut ret = ::std::collections::HashMap::new();
                                 ret.insert("Integer".to_owned(), vec!["0".to_owned()]);
                                 ret.insert("Boolean".to_owned(), vec!["false".to_owned()]);
                                 ret
                             }),
                             query_string: ::std::option::Option::None,
                             query_string_list: ::std::option::Option::None,
                             query_string_set: ::std::option::Option::None,
                             query_byte: ::std::option::Option::None,
                             query_short: ::std::option::Option::None,
                             query_integer_list: ::std::option::Option::None,
                             query_integer_set: ::std::option::Option::None,
                             query_long: ::std::option::Option::None,
                             query_float: ::std::option::Option::None,
                             query_double: ::std::option::Option::None,
                             query_double_list: ::std::option::Option::None,
                             query_boolean_list: ::std::option::Option::None,
                             query_timestamp: ::std::option::Option::None,
                             query_timestamp_list: ::std::option::Option::None,
                             query_enum: ::std::option::Option::None,
                             query_enum_list: ::std::option::Option::None,
                             query_integer_enum: ::std::option::Option::None,
                             query_integer_enum_list: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(
                             input.query_string,
                             expected.query_string,
                             "Unexpected value for `query_string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_list,
                             expected.query_string_list,
                             "Unexpected value for `query_string_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_string_set,
                             expected.query_string_set,
                             "Unexpected value for `query_string_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_byte,
                             expected.query_byte,
                             "Unexpected value for `query_byte`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_short,
                             expected.query_short,
                             "Unexpected value for `query_short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer,
                             expected.query_integer,
                             "Unexpected value for `query_integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_list,
                             expected.query_integer_list,
                             "Unexpected value for `query_integer_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_set,
                             expected.query_integer_set,
                             "Unexpected value for `query_integer_set`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_long,
                             expected.query_long,
                             "Unexpected value for `query_long`"
                         );
                         assert!(
                             input.query_float.float_equals(&expected.query_float),
                             "Unexpected value for `query_float` {:?} vs. {:?}",
                             expected.query_float,
                             input.query_float
                         );
                         assert!(
                             input.query_double.float_equals(&expected.query_double),
                             "Unexpected value for `query_double` {:?} vs. {:?}",
                             expected.query_double,
                             input.query_double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_double_list,
                             expected.query_double_list,
                             "Unexpected value for `query_double_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean,
                             expected.query_boolean,
                             "Unexpected value for `query_boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_boolean_list,
                             expected.query_boolean_list,
                             "Unexpected value for `query_boolean_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp,
                             expected.query_timestamp,
                             "Unexpected value for `query_timestamp`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_timestamp_list,
                             expected.query_timestamp_list,
                             "Unexpected value for `query_timestamp_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum,
                             expected.query_enum,
                             "Unexpected value for `query_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_enum_list,
                             expected.query_enum_list,
                             "Unexpected value for `query_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum,
                             expected.query_integer_enum,
                             "Unexpected value for `query_integer_enum`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_integer_enum_list,
                             expected.query_integer_enum_list,
                             "Unexpected value for `query_integer_enum_list`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.query_params_map_of_string_list,
                             expected.query_params_map_of_string_list,
                             "Unexpected value for `query_params_map_of_string_list`"
                         );
                         let response = crate::output::AllQueryStringTypesOutput {};
                         Ok(response)
                     };
                     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"
         );
-38084
+    }
-38085
+}
-38086
 const CONTENT_TYPE_HTTPPREFIXHEADERSINRESPONSE: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_HTTPREQUESTWITHREGEXLITERAL: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPrefixHeadersInResponseInput`](crate::input::HttpPrefixHeadersInResponseInput) using modelled bindings.
     pub struct HttpPrefixHeadersInResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpRequestWithRegexLiteralInput`](crate::input::HttpRequestWithRegexLiteralInput) using modelled bindings.
     pub struct HttpRequestWithRegexLiteralInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithRegexLiteralInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-38093
+    }
-38094
+}
-38095
 impl std::future::Future for HttpPrefixHeadersInResponseInputFuture {
 impl std::future::Future for HttpRequestWithRegexLiteralInputFuture {
     type Output = Result<
         crate::input::HttpPrefixHeadersInResponseInput,
         crate::input::HttpRequestWithRegexLiteralInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-38101
     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)
-38108
+    }
-38109
+}
-38110
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersInResponseInput
     > for crate::input::HttpRequestWithRegexLiteralInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38119
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38123
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersInResponseInputFuture;
     type Future = HttpRequestWithRegexLiteralInputFuture;
-38126
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPREFIXHEADERSINRESPONSE,
                 &CONTENT_TYPE_HTTPREQUESTWITHREGEXLITERAL,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38134
+            }
             crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_http_request(request)
             crate::protocol_serde::shape_http_request_with_regex_literal::de_http_request_with_regex_literal_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38145
+                )
             },
         );
         HttpPrefixHeadersInResponseInputFuture {
         HttpRequestWithRegexLiteralInputFuture {
             inner: Box::pin(fut),
-38150
+        }
-38151
+    }
-38152
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersInResponseOutput
     > for crate::output::HttpRequestWithRegexLiteralOutput
-38157
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers_in_response::ser_http_prefix_headers_in_response_http_response(self) {
         match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38164
+                        }
-38165
+                    }
-38166
+    }
-38167
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithRegexLiteralError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-38186
 const CONTENT_TYPE_HTTPPREFIXHEADERS: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_regex_literal_test {
-+
     /// Path matching is not broken by regex expressions in literal segments
     /// Test ID: RestJsonToleratesRegexCharsInSegments
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_tolerates_regex_chars_in_segments_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/ReDosLiteral/abc/(a+)+")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_regex_literal(
                 move |input: crate::input::HttpRequestWithRegexLiteralInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpRequestWithRegexLiteralInput {
                                 str: "abc".to_owned(),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpRequestWithRegexLiteralOutput {};
                             Ok(response)
                         };
                         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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_HTTPREQUESTWITHFLOATLABELS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpPrefixHeadersInput`](crate::input::HttpPrefixHeadersInput) using modelled bindings.
     pub struct HttpPrefixHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpPrefixHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpRequestWithFloatLabelsInput`](crate::input::HttpRequestWithFloatLabelsInput) using modelled bindings.
     pub struct HttpRequestWithFloatLabelsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithFloatLabelsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-38242
+    }
-38243
+}
-38244
 impl std::future::Future for HttpPrefixHeadersInputFuture {
 impl std::future::Future for HttpRequestWithFloatLabelsInputFuture {
     type Output = Result<
         crate::input::HttpPrefixHeadersInput,
         crate::input::HttpRequestWithFloatLabelsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-38250
     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)
-38257
+    }
-38258
+}
-38259
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpPrefixHeadersInput
     > for crate::input::HttpRequestWithFloatLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38268
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38272
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpPrefixHeadersInputFuture;
     type Future = HttpRequestWithFloatLabelsInputFuture;
-38275
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPPREFIXHEADERS,
                 &CONTENT_TYPE_HTTPREQUESTWITHFLOATLABELS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38283
+            }
             crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_http_request(
                 request,
--
+            )
             .await
             .map_err(Into::into)
             crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38294
+                )
             },
         );
         HttpPrefixHeadersInputFuture {
         HttpRequestWithFloatLabelsInputFuture {
             inner: Box::pin(fut),
-38299
+        }
-38300
+    }
-38301
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpPrefixHeadersOutput
     > for crate::output::HttpRequestWithFloatLabelsOutput
-38306
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_prefix_headers::ser_http_prefix_headers_http_response(self) {
         match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38313
+                        }
-38314
+                    }
-38315
+    }
-38316
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithFloatLabelsError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-38335
 const CONTENT_TYPE_QUERYPARAMSASSTRINGLISTMAP: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_float_labels_test {
-+
     /// Supports handling NaN float label values.
     /// Test ID: RestJsonSupportsNaNFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_labels_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/FloatHttpLabels/NaN/NaN")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .http_request_with_float_labels(move |input: crate::input::HttpRequestWithFloatLabelsInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::HttpRequestWithFloatLabelsInput {
                 float:
                     <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                ,
                 double:
                     <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                ,
-+
+            }
-+
+        ;
         assert!(input.float.float_equals(&expected.float),
                                             "Unexpected value for `float` {:?} vs. {:?}", expected.float, input.float);
         assert!(input.double.float_equals(&expected.double),
                                             "Unexpected value for `double` {:?} vs. {:?}", expected.double, input.double);
         let response =
             crate::output::HttpRequestWithFloatLabelsOutput {
-+
+            }
-+
+        ;
         Ok(response) };
                                 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"
         );
-+
+    }
     /// Supports handling Infinity float label values.
     /// Test ID: RestJsonSupportsInfinityFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_labels_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/FloatHttpLabels/Infinity/Infinity")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .http_request_with_float_labels(move |input: crate::input::HttpRequestWithFloatLabelsInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::HttpRequestWithFloatLabelsInput {
                 float:
                     <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                ,
                 double:
                     <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                ,
-+
+            }
-+
+        ;
         assert!(input.float.float_equals(&expected.float),
                                             "Unexpected value for `float` {:?} vs. {:?}", expected.float, input.float);
         assert!(input.double.float_equals(&expected.double),
                                             "Unexpected value for `double` {:?} vs. {:?}", expected.double, input.double);
         let response =
             crate::output::HttpRequestWithFloatLabelsOutput {
-+
+            }
-+
+        ;
         Ok(response) };
                                 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"
         );
-+
+    }
     /// Supports handling -Infinity float label values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatLabels
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_labels_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/FloatHttpLabels/-Infinity/-Infinity")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .http_request_with_float_labels(move |input: crate::input::HttpRequestWithFloatLabelsInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::HttpRequestWithFloatLabelsInput {
                 float:
                     <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                ,
                 double:
                     <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                ,
-+
+            }
-+
+        ;
         assert!(input.float.float_equals(&expected.float),
                                             "Unexpected value for `float` {:?} vs. {:?}", expected.float, input.float);
         assert!(input.double.float_equals(&expected.double),
                                             "Unexpected value for `double` {:?} vs. {:?}", expected.double, input.double);
         let response =
             crate::output::HttpRequestWithFloatLabelsOutput {
-+
+            }
-+
+        ;
         Ok(response) };
                                 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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_HTTPREQUESTWITHGREEDYLABELINPATH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryParamsAsStringListMapInput`](crate::input::QueryParamsAsStringListMapInput) using modelled bindings.
     pub struct QueryParamsAsStringListMapInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryParamsAsStringListMapInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpRequestWithGreedyLabelInPathInput`](crate::input::HttpRequestWithGreedyLabelInPathInput) using modelled bindings.
     pub struct HttpRequestWithGreedyLabelInPathInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithGreedyLabelInPathInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-38507
+    }
-38508
+}
-38509
 impl std::future::Future for QueryParamsAsStringListMapInputFuture {
 impl std::future::Future for HttpRequestWithGreedyLabelInPathInputFuture {
     type Output = Result<
         crate::input::QueryParamsAsStringListMapInput,
         crate::input::HttpRequestWithGreedyLabelInPathInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-38515
     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)
-38522
+    }
-38523
+}
-38524
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryParamsAsStringListMapInput
     > for crate::input::HttpRequestWithGreedyLabelInPathInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38533
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38537
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryParamsAsStringListMapInputFuture;
     type Future = HttpRequestWithGreedyLabelInPathInputFuture;
-38540
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPARAMSASSTRINGLISTMAP,
                 &CONTENT_TYPE_HTTPREQUESTWITHGREEDYLABELINPATH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38548
+            }
             crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_http_request(request)
             crate::protocol_serde::shape_http_request_with_greedy_label_in_path::de_http_request_with_greedy_label_in_path_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38559
+                )
             },
         );
         QueryParamsAsStringListMapInputFuture {
         HttpRequestWithGreedyLabelInPathInputFuture {
             inner: Box::pin(fut),
-38564
+        }
-38565
+    }
-38566
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryParamsAsStringListMapOutput
     > for crate::output::HttpRequestWithGreedyLabelInPathOutput
-38571
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_params_as_string_list_map::ser_query_params_as_string_list_map_http_response(self) {
         match crate::protocol_serde::shape_http_request_with_greedy_label_in_path::ser_http_request_with_greedy_label_in_path_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38578
+                        }
-38579
+                    }
-38580
+    }
-38581
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithGreedyLabelInPathError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_greedy_label_in_path::ser_http_request_with_greedy_label_in_path_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-+
+    }
-+
+}
-38600
 const CONTENT_TYPE_QUERYPRECEDENCE: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_greedy_label_in_path_test {
-+
     /// Serializes greedy labels and normal labels
     /// Test ID: RestJsonHttpRequestWithGreedyLabelInPath
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_request_with_greedy_label_in_path_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpRequestWithGreedyLabelInPath/foo/hello%2Fescape/baz/there/guy")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_greedy_label_in_path(
                 move |input: crate::input::HttpRequestWithGreedyLabelInPathInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::HttpRequestWithGreedyLabelInPathInput {
                                 foo: "hello/escape".to_owned(),
                                 baz: "there/guy".to_owned(),
                             };
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::HttpRequestWithGreedyLabelInPathOutput {};
                             Ok(response)
                         };
                         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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_HTTPREQUESTWITHLABELSANDTIMESTAMPFORMAT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryPrecedenceInput`](crate::input::QueryPrecedenceInput) using modelled bindings.
     pub struct QueryPrecedenceInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryPrecedenceInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpRequestWithLabelsAndTimestampFormatInput`](crate::input::HttpRequestWithLabelsAndTimestampFormatInput) using modelled bindings.
     pub struct HttpRequestWithLabelsAndTimestampFormatInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsAndTimestampFormatInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-38657
+    }
-38658
+}
-38659
 impl std::future::Future for QueryPrecedenceInputFuture {
 impl std::future::Future for HttpRequestWithLabelsAndTimestampFormatInputFuture {
     type Output = Result<
         crate::input::QueryPrecedenceInput,
         crate::input::HttpRequestWithLabelsAndTimestampFormatInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-38665
     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)
-38672
+    }
-38673
+}
-38674
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
     > for crate::input::HttpRequestWithLabelsAndTimestampFormatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38683
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38687
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
     type Future = HttpRequestWithLabelsAndTimestampFormatInputFuture;
-38690
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPRECEDENCE,
                 &CONTENT_TYPE_HTTPREQUESTWITHLABELSANDTIMESTAMPFORMAT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38698
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::de_http_request_with_labels_and_timestamp_format_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38709
+                )
             },
         );
         QueryPrecedenceInputFuture {
         HttpRequestWithLabelsAndTimestampFormatInputFuture {
             inner: Box::pin(fut),
-38714
+        }
-38715
+    }
-38716
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
     > for crate::output::HttpRequestWithLabelsAndTimestampFormatOutput
-38721
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
             Ok(response) => response,
         match crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::ser_http_request_with_labels_and_timestamp_format_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+                        }
-+
+                    }
-+
+    }
-+
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithLabelsAndTimestampFormatError
-+
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::ser_http_request_with_labels_and_timestamp_format_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38746
+            }
-38747
+        }
-38748
+    }
-38749
+}
-38750
 const CONTENT_TYPE_QUERYIDEMPOTENCYTOKENAUTOFILL: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`QueryIdempotencyTokenAutoFillInput`](crate::input::QueryIdempotencyTokenAutoFillInput) using modelled bindings.
     pub struct QueryIdempotencyTokenAutoFillInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::QueryIdempotencyTokenAutoFillInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for QueryIdempotencyTokenAutoFillInputFuture {
     type Output = Result<
         crate::input::QueryIdempotencyTokenAutoFillInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryIdempotencyTokenAutoFillInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryIdempotencyTokenAutoFillInputFuture;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_labels_and_timestamp_format_test {
-38754
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYIDEMPOTENCYTOKENAUTOFILL,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
     /// Serializes different timestamp formats in URI labels
     /// Test ID: RestJsonHttpRequestWithLabelsAndTimestampFormat
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_request_with_labels_and_timestamp_format_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/HttpRequestWithLabelsAndTimestampFormat/1576540098/Mon%2C%2016%20Dec%202019%2023%3A48%3A18%20GMT/2019-12-16T23%3A48%3A18Z/2019-12-16T23%3A48%3A18Z/1576540098/Mon%2C%2016%20Dec%202019%2023%3A48%3A18%20GMT/2019-12-16T23%3A48%3A18Z")
                         .method("GET")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service =
             crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                 .http_request_with_labels_and_timestamp_format(
                     move |input: crate::input::HttpRequestWithLabelsAndTimestampFormatInput| {
                         let sender = sender.clone();
                         async move {
                             let result =
-+
+                                {
                                     let expected =
             crate::input::HttpRequestWithLabelsAndTimestampFormatInput {
                 member_epoch_seconds:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
                 member_http_date:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
                 member_date_time:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
                 default_format:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
                 target_epoch_seconds:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
                 target_http_date:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
                 target_date_time:
                     ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64)
-+
+                ,
-38799
+            }
             crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-+
+        ;
                                     ::pretty_assertions::assert_eq!(input, expected);
                                     let response =
             crate::output::HttpRequestWithLabelsAndTimestampFormatOutput {
-+
+            }
-+
+        ;
                                     Ok(response)
                                 };
                             sender.send(()).await.expect("receiver dropped early");
                             result
-+
+                        }
                     },
-38812
+                )
             },
                 .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"
         );
         QueryIdempotencyTokenAutoFillInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryIdempotencyTokenAutoFillOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_idempotency_token_auto_fill::ser_query_idempotency_token_auto_fill_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
-38821
+    }
-38822
+}
-38823
 const CONTENT_TYPE_OMITSSERIALIZINGEMPTYLISTS: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_HTTPREQUESTWITHLABELS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OmitsSerializingEmptyListsInput`](crate::input::OmitsSerializingEmptyListsInput) using modelled bindings.
     pub struct OmitsSerializingEmptyListsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsSerializingEmptyListsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`HttpRequestWithLabelsInput`](crate::input::HttpRequestWithLabelsInput) using modelled bindings.
     pub struct HttpRequestWithLabelsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-38830
+    }
-38831
+}
-38832
 impl std::future::Future for OmitsSerializingEmptyListsInputFuture {
 impl std::future::Future for HttpRequestWithLabelsInputFuture {
     type Output = Result<
         crate::input::OmitsSerializingEmptyListsInput,
         crate::input::HttpRequestWithLabelsInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-38838
     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)
-38845
+    }
-38846
+}
-38847
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OmitsSerializingEmptyListsInput
     > for crate::input::HttpRequestWithLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38856
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38860
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OmitsSerializingEmptyListsInputFuture;
     type Future = HttpRequestWithLabelsInputFuture;
-38863
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OMITSSERIALIZINGEMPTYLISTS,
                 &CONTENT_TYPE_HTTPREQUESTWITHLABELS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-38871
+            }
             crate::protocol_serde::shape_omits_serializing_empty_lists::de_omits_serializing_empty_lists_http_request(request)
             crate::protocol_serde::shape_http_request_with_labels::de_http_request_with_labels_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-38882
+                )
             },
         );
         OmitsSerializingEmptyListsInputFuture {
         HttpRequestWithLabelsInputFuture {
             inner: Box::pin(fut),
-38887
+        }
-38888
+    }
-38889
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OmitsSerializingEmptyListsOutput
     > for crate::output::HttpRequestWithLabelsOutput
-38894
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_response(self) {
         match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38901
+                        }
-38902
+                    }
-38903
+    }
-38904
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::OmitsSerializingEmptyListsError
     > for crate::error::HttpRequestWithLabelsError
-38909
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_error(&self) {
         match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-38919
+            }
-38920
+        }
-38921
+    }
-38922
+}
-38923
 const CONTENT_TYPE_OMITSNULLSERIALIZESEMPTYSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod http_request_with_labels_test {
-+
     /// Sends a GET request that uses URI label bindings
     /// Test ID: RestJsonInputWithHeadersAndAllParams
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_with_headers_and_all_params_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/HttpRequestWithLabels/string/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z")
             .method("GET")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_labels(move |input: crate::input::HttpRequestWithLabelsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::HttpRequestWithLabelsInput {
                             string: "string".to_owned(),
                             short: 1,
                             integer: 2,
                             long: 3,
                             float: 4.1_f32,
                             double: 5.1_f64,
                             boolean: true,
                             timestamp: ::aws_smithy_types::DateTime::from_fractional_secs(
                                 1576540098, 0_f64,
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.string,
                             expected.string,
                             "Unexpected value for `string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short,
                             expected.short,
                             "Unexpected value for `short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer,
                             expected.integer,
                             "Unexpected value for `integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long,
                             expected.long,
                             "Unexpected value for `long`"
                         );
                         assert!(
                             input.float.float_equals(&expected.float),
                             "Unexpected value for `float` {:?} vs. {:?}",
                             expected.float,
                             input.float
                         );
                         assert!(
                             input.double.float_equals(&expected.double),
                             "Unexpected value for `double` {:?} vs. {:?}",
                             expected.double,
                             input.double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.boolean,
                             expected.boolean,
                             "Unexpected value for `boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.timestamp,
                             expected.timestamp,
                             "Unexpected value for `timestamp`"
                         );
                         let response = crate::output::HttpRequestWithLabelsOutput {};
                         Ok(response)
                     };
                     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"
         );
-+
+    }
     /// Sends a GET request that uses URI label bindings
     /// Test ID: RestJsonHttpRequestLabelEscaping
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_http_request_label_escaping_request() {
         #[allow(unused_mut)]
                     let mut http_request = http::Request::builder()
                         .uri("/HttpRequestWithLabels/%20%25%3A%2F%3F%23%5B%5D%40%21%24%26%27%28%29%2A%2B%2C%3B%3D%F0%9F%98%B9/1/2/3/4.1/5.1/true/2019-12-16T23%3A48%3A18Z")
                         .method("GET")
         .body(::aws_smithy_http_server::body::Body::from(::bytes::Bytes::from_static("".as_bytes()))).unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .http_request_with_labels(move |input: crate::input::HttpRequestWithLabelsInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         use ::aws_smithy_protocol_test::FloatEquals;
                         let expected = crate::input::HttpRequestWithLabelsInput {
                             string: " %:/?#[]@!$&'()*+,;=😹".to_owned(),
                             short: 1,
                             integer: 2,
                             long: 3,
                             float: 4.1_f32,
                             double: 5.1_f64,
                             boolean: true,
                             timestamp: ::aws_smithy_types::DateTime::from_fractional_secs(
                                 1576540098, 0_f64,
                             ),
                         };
                         ::pretty_assertions::assert_eq!(
                             input.string,
                             expected.string,
                             "Unexpected value for `string`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.short,
                             expected.short,
                             "Unexpected value for `short`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.integer,
                             expected.integer,
                             "Unexpected value for `integer`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.long,
                             expected.long,
                             "Unexpected value for `long`"
                         );
                         assert!(
                             input.float.float_equals(&expected.float),
                             "Unexpected value for `float` {:?} vs. {:?}",
                             expected.float,
                             input.float
                         );
                         assert!(
                             input.double.float_equals(&expected.double),
                             "Unexpected value for `double` {:?} vs. {:?}",
                             expected.double,
                             input.double
                         );
                         ::pretty_assertions::assert_eq!(
                             input.boolean,
                             expected.boolean,
                             "Unexpected value for `boolean`"
                         );
                         ::pretty_assertions::assert_eq!(
                             input.timestamp,
                             expected.timestamp,
                             "Unexpected value for `timestamp`"
                         );
                         let response = crate::output::HttpRequestWithLabelsOutput {};
                         Ok(response)
                     };
                     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"
         );
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_MEDIATYPEHEADER: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`OmitsNullSerializesEmptyStringInput`](crate::input::OmitsNullSerializesEmptyStringInput) using modelled bindings.
     pub struct OmitsNullSerializesEmptyStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::OmitsNullSerializesEmptyStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`MediaTypeHeaderInput`](crate::input::MediaTypeHeaderInput) using modelled bindings.
     pub struct MediaTypeHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MediaTypeHeaderInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-39117
+    }
-39118
+}
-39119
 impl std::future::Future for OmitsNullSerializesEmptyStringInputFuture {
 impl std::future::Future for MediaTypeHeaderInputFuture {
     type Output = Result<
         crate::input::OmitsNullSerializesEmptyStringInput,
         crate::input::MediaTypeHeaderInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-39125
     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)
-39132
+    }
-39133
+}
-39134
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OmitsNullSerializesEmptyStringInput
     > for crate::input::MediaTypeHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39143
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39147
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = OmitsNullSerializesEmptyStringInputFuture;
     type Future = MediaTypeHeaderInputFuture;
-39150
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OMITSNULLSERIALIZESEMPTYSTRING,
                 &CONTENT_TYPE_MEDIATYPEHEADER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39158
+            }
             crate::protocol_serde::shape_omits_null_serializes_empty_string::de_omits_null_serializes_empty_string_http_request(request)
                             .await
                             .map_err(Into::into)
             crate::protocol_serde::shape_media_type_header::de_media_type_header_http_request(
                 request,
-+
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39171
+                )
             },
         );
         OmitsNullSerializesEmptyStringInputFuture {
         MediaTypeHeaderInputFuture {
             inner: Box::pin(fut),
-39176
+        }
-39177
+    }
-39178
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OmitsNullSerializesEmptyStringOutput
     > for crate::output::MediaTypeHeaderOutput
-39183
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_omits_null_serializes_empty_string::ser_omits_null_serializes_empty_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         match crate::protocol_serde::shape_media_type_header::ser_media_type_header_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-+
+            }
-+
+        }
-39194
+    }
-39195
+}
-39196
 const CONTENT_TYPE_IGNOREQUERYPARAMSINRESPONSE: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod media_type_header_test {
-+
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderInputBase64
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn media_type_header_input_base64_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/MediaTypeHeader")
             .method("GET")
             .header("X-Json", "dHJ1ZQ==")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .media_type_header(move |input: crate::input::MediaTypeHeaderInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::MediaTypeHeaderInput {
                             json: ::std::option::Option::Some("true".to_owned()),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::MediaTypeHeaderOutput {
                             json: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Headers that target strings with a mediaType are base64 encoded
     /// Test ID: MediaTypeHeaderOutputBase64
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn media_type_header_output_base64_response() {
         let output = crate::output::MediaTypeHeaderOutput {
             json: ::std::option::Option::Some("true".to_owned()),
         };
         use ::aws_smithy_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-Json", "dHJ1ZQ==")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_TIMESTAMPFORMATHEADERS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`IgnoreQueryParamsInResponseInput`](crate::input::IgnoreQueryParamsInResponseInput) using modelled bindings.
     pub struct IgnoreQueryParamsInResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::IgnoreQueryParamsInResponseInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`TimestampFormatHeadersInput`](crate::input::TimestampFormatHeadersInput) using modelled bindings.
     pub struct TimestampFormatHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TimestampFormatHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-39273
+    }
-39274
+}
-39275
 impl std::future::Future for IgnoreQueryParamsInResponseInputFuture {
 impl std::future::Future for TimestampFormatHeadersInputFuture {
     type Output = Result<
         crate::input::IgnoreQueryParamsInResponseInput,
         crate::input::TimestampFormatHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-39281
     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)
-39288
+    }
-39289
+}
-39290
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::IgnoreQueryParamsInResponseInput
     > for crate::input::TimestampFormatHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39299
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39303
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = IgnoreQueryParamsInResponseInputFuture;
     type Future = TimestampFormatHeadersInputFuture;
-39306
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_IGNOREQUERYPARAMSINRESPONSE,
                 &CONTENT_TYPE_TIMESTAMPFORMATHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39314
+            }
             crate::protocol_serde::shape_ignore_query_params_in_response::de_ignore_query_params_in_response_http_request(request)
             crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39325
+                )
             },
         );
         IgnoreQueryParamsInResponseInputFuture {
         TimestampFormatHeadersInputFuture {
             inner: Box::pin(fut),
-39330
+        }
-39331
+    }
-39332
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::IgnoreQueryParamsInResponseOutput
     > for crate::output::TimestampFormatHeadersOutput
-39337
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_ignore_query_params_in_response::ser_ignore_query_params_in_response_http_response(self) {
         match crate::protocol_serde::shape_timestamp_format_headers::ser_timestamp_format_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39344
+                        }
-39345
+                    }
-39346
+    }
-39347
+}
-39348
 const CONTENT_TYPE_CONSTANTANDVARIABLEQUERYSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod timestamp_format_headers_test {
-+
     /// Tests how timestamp request headers are serialized
     /// Test ID: RestJsonTimestampFormatHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_timestamp_format_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/TimestampFormatHeaders")
             .method("POST")
             .header("X-defaultFormat", "Mon, 16 Dec 2019 23:48:18 GMT")
             .header("X-memberDateTime", "2019-12-16T23:48:18Z")
             .header("X-memberEpochSeconds", "1576540098")
             .header("X-memberHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT")
             .header("X-targetDateTime", "2019-12-16T23:48:18Z")
             .header("X-targetEpochSeconds", "1576540098")
             .header("X-targetHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .timestamp_format_headers(move |input: crate::input::TimestampFormatHeadersInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::TimestampFormatHeadersInput {
                             member_epoch_seconds: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             member_http_date: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             member_date_time: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             default_format: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             target_epoch_seconds: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             target_http_date: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                             target_date_time: ::std::option::Option::Some(
                                 ::aws_smithy_types::DateTime::from_fractional_secs(
                                     1576540098, 0_f64,
                                 ),
                             ),
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::TimestampFormatHeadersOutput {
                             member_epoch_seconds: ::std::option::Option::None,
                             member_http_date: ::std::option::Option::None,
                             member_date_time: ::std::option::Option::None,
                             default_format: ::std::option::Option::None,
                             target_epoch_seconds: ::std::option::Option::None,
                             target_http_date: ::std::option::Option::None,
                             target_date_time: ::std::option::Option::None,
                         };
                         response
                     };
                     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"
         );
-+
+    }
     /// Tests how timestamp response headers are serialized
     /// Test ID: RestJsonTimestampFormatHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_timestamp_format_headers_response() {
         let output = crate::output::TimestampFormatHeadersOutput {
             member_epoch_seconds: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             member_http_date: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             member_date_time: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             default_format: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             target_epoch_seconds: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             target_http_date: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
             target_date_time: ::std::option::Option::Some(
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ),
         };
         use ::aws_smithy_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-defaultFormat", "Mon, 16 Dec 2019 23:48:18 GMT"),
             ("X-memberDateTime", "2019-12-16T23:48:18Z"),
             ("X-memberEpochSeconds", "1576540098"),
             ("X-memberHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT"),
             ("X-targetDateTime", "2019-12-16T23:48:18Z"),
             ("X-targetEpochSeconds", "1576540098"),
             ("X-targetHttpDate", "Mon, 16 Dec 2019 23:48:18 GMT"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_NULLANDEMPTYHEADERSSERVER: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ConstantAndVariableQueryStringInput`](crate::input::ConstantAndVariableQueryStringInput) using modelled bindings.
     pub struct ConstantAndVariableQueryStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantAndVariableQueryStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`NullAndEmptyHeadersServerInput`](crate::input::NullAndEmptyHeadersServerInput) using modelled bindings.
     pub struct NullAndEmptyHeadersServerInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersServerInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-39499
+    }
-39500
+}
-39501
 impl std::future::Future for ConstantAndVariableQueryStringInputFuture {
 impl std::future::Future for NullAndEmptyHeadersServerInputFuture {
     type Output = Result<
         crate::input::ConstantAndVariableQueryStringInput,
         crate::input::NullAndEmptyHeadersServerInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-39507
     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)
-39514
+    }
-39515
+}
-39516
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstantAndVariableQueryStringInput
     > for crate::input::NullAndEmptyHeadersServerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39525
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39529
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstantAndVariableQueryStringInputFuture;
     type Future = NullAndEmptyHeadersServerInputFuture;
-39532
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTANTANDVARIABLEQUERYSTRING,
                 &CONTENT_TYPE_NULLANDEMPTYHEADERSSERVER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39540
+            }
             crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_http_request(request)
             crate::protocol_serde::shape_null_and_empty_headers_server::de_null_and_empty_headers_server_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39551
+                )
             },
         );
         ConstantAndVariableQueryStringInputFuture {
         NullAndEmptyHeadersServerInputFuture {
             inner: Box::pin(fut),
-39556
+        }
-39557
+    }
-39558
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstantAndVariableQueryStringOutput
     > for crate::output::NullAndEmptyHeadersServerOutput
-39563
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_and_variable_query_string::ser_constant_and_variable_query_string_http_response(self) {
         match crate::protocol_serde::shape_null_and_empty_headers_server::ser_null_and_empty_headers_server_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39570
+                        }
-39571
+                    }
-39572
+    }
-39573
+}
-39574
 const CONTENT_TYPE_CONSTANTQUERYSTRING: ::mime::Mime = ::mime::APPLICATION_JSON;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod null_and_empty_headers_server_test {
-+
     /// Do not send null or empty headers
     /// Test ID: RestJsonNullAndEmptyHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_null_and_empty_headers_response() {
         let output = crate::output::NullAndEmptyHeadersServerOutput {
             a: ::std::option::Option::None,
             b: ::std::option::Option::Some("".to_owned()),
             c: ::std::option::Option::Some(vec![]),
         };
         use ::aws_smithy_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 forbidden_headers = &["X-A", "X-B", "X-C"];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::forbid_headers(
             http_response.headers(),
             forbidden_headers,
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_NULLANDEMPTYHEADERSCLIENT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ConstantQueryStringInput`](crate::input::ConstantQueryStringInput) using modelled bindings.
     pub struct ConstantQueryStringInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ConstantQueryStringInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`NullAndEmptyHeadersClientInput`](crate::input::NullAndEmptyHeadersClientInput) using modelled bindings.
     pub struct NullAndEmptyHeadersClientInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersClientInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-39609
+    }
-39610
+}
-39611
 impl std::future::Future for ConstantQueryStringInputFuture {
 impl std::future::Future for NullAndEmptyHeadersClientInputFuture {
     type Output = Result<
         crate::input::ConstantQueryStringInput,
         crate::input::NullAndEmptyHeadersClientInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-39617
     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)
-39624
+    }
-39625
+}
-39626
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::ConstantQueryStringInput
     > for crate::input::NullAndEmptyHeadersClientInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39635
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39639
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = ConstantQueryStringInputFuture;
     type Future = NullAndEmptyHeadersClientInputFuture;
-39642
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CONSTANTQUERYSTRING,
                 &CONTENT_TYPE_NULLANDEMPTYHEADERSCLIENT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39650
+            }
             crate::protocol_serde::shape_constant_query_string::de_constant_query_string_http_request(request)
             crate::protocol_serde::shape_null_and_empty_headers_client::de_null_and_empty_headers_client_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39661
+                )
             },
         );
         ConstantQueryStringInputFuture {
         NullAndEmptyHeadersClientInputFuture {
             inner: Box::pin(fut),
-39666
+        }
-39667
+    }
-39668
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::ConstantQueryStringOutput
     > for crate::output::NullAndEmptyHeadersClientOutput
-39673
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_response(self) {
         match crate::protocol_serde::shape_null_and_empty_headers_client::ser_null_and_empty_headers_client_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39680
+                        }
-39681
+                    }
-39682
+    }
-39683
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::ConstantQueryStringError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
-39684
 const CONTENT_TYPE_ALLQUERYSTRINGTYPES: ::mime::Mime = ::mime::APPLICATION_JSON;
 const CONTENT_TYPE_INPUTANDOUTPUTWITHHEADERS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`AllQueryStringTypesInput`](crate::input::AllQueryStringTypesInput) using modelled bindings.
     pub struct AllQueryStringTypesInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::AllQueryStringTypesInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// [`InputAndOutputWithHeadersInput`](crate::input::InputAndOutputWithHeadersInput) using modelled bindings.
     pub struct InputAndOutputWithHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::InputAndOutputWithHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-39691
+    }
-39692
+}
-39693
 impl std::future::Future for AllQueryStringTypesInputFuture {
 impl std::future::Future for InputAndOutputWithHeadersInputFuture {
     type Output = Result<
         crate::input::AllQueryStringTypesInput,
         crate::input::InputAndOutputWithHeadersInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-39699
     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)
-39706
+    }
-39707
+}
-39708
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::AllQueryStringTypesInput
     > for crate::input::InputAndOutputWithHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39717
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-39721
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = AllQueryStringTypesInputFuture;
     type Future = InputAndOutputWithHeadersInputFuture;
-39724
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ALLQUERYSTRINGTYPES,
                 &CONTENT_TYPE_INPUTANDOUTPUTWITHHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-39732
+            }
             crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_http_request(request)
             crate::protocol_serde::shape_input_and_output_with_headers::de_input_and_output_with_headers_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-39743
+                )
             },
         );
         AllQueryStringTypesInputFuture {
         InputAndOutputWithHeadersInputFuture {
             inner: Box::pin(fut),
-39748
+        }
-39749
+    }
-39750
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::AllQueryStringTypesOutput
     > for crate::output::InputAndOutputWithHeadersOutput
-39755
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_response(self) {
         match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39762
+                        }
-39763
+                    }
-39764
+    }
-39765
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::AllQueryStringTypesError
     > for crate::error::InputAndOutputWithHeadersError
-39770
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_error(&self) {
         match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-39780
+            }
-39781
+        }
-39782
+    }
-39783
+}
-39784
 const CONTENT_TYPE_HTTPREQUESTWITHREGEXLITERAL: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithRegexLiteralInput`](crate::input::HttpRequestWithRegexLiteralInput) using modelled bindings.
     pub struct HttpRequestWithRegexLiteralInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithRegexLiteralInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpRequestWithRegexLiteralInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithRegexLiteralInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithRegexLiteralInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithRegexLiteralInputFuture;
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod input_and_output_with_headers_test {
-39788
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHREGEXLITERAL,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_request_with_regex_literal::de_http_request_with_regex_literal_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Tests requests with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_string_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-String", "Hello")
             .header("X-StringList", "a, b, c")
             .header("X-StringSet", "a, b, c")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_string: ::std::option::Option::Some("Hello".to_owned()),
                                 header_string_list: ::std::option::Option::Some(vec![
                                     "a".to_owned(),
                                     "b".to_owned(),
                                     "c".to_owned(),
                                 ]),
                                 header_string_set: ::std::option::Option::Some(
                                     vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]
                                         .try_into()
                                         .expect("this is only used in tests"),
                                 ),
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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"
         );
         HttpRequestWithRegexLiteralInputFuture {
             inner: Box::pin(fut),
--
+        }
-39970
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithRegexLiteralOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
     /// Tests requests with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_quoted_string_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-StringList", "\"b,c\", \"\\\"def\\\"\", a")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_string_list: ::std::option::Option::Some(vec![
                                     "b,c".to_owned(),
                                     "\"def\"".to_owned(),
                                     "a".to_owned(),
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-40135
+                    }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithRegexLiteralError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPREQUESTWITHFLOATLABELS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithFloatLabelsInput`](crate::input::HttpRequestWithFloatLabelsInput) using modelled bindings.
     pub struct HttpRequestWithFloatLabelsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithFloatLabelsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpRequestWithFloatLabelsInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithFloatLabelsInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithFloatLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithFloatLabelsInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHFLOATLABELS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
                 },
-+
+            )
             .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"
         );
         HttpRequestWithFloatLabelsInputFuture {
             inner: Box::pin(fut),
--
+        }
-40146
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithFloatLabelsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
     /// Tests requests with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_numeric_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Byte", "1")
             .header("X-Double", "1.1")
             .header("X-Float", "1.1")
             .header("X-Integer", "123")
             .header("X-IntegerList", "1, 2, 3")
             .header("X-Long", "123")
             .header("X-Short", "123")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_byte: ::std::option::Option::Some(1),
                                 header_short: ::std::option::Option::Some(123),
                                 header_integer: ::std::option::Option::Some(123),
                                 header_long: ::std::option::Option::Some(123),
                                 header_float: ::std::option::Option::Some(1.1_f32),
                                 header_double: ::std::option::Option::Some(1.1_f64),
                                 header_integer_list: ::std::option::Option::Some(vec![1, 2, 3]),
                                 header_string: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-40313
+                    }
                 },
-+
+            )
             .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"
         );
-40324
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithFloatLabelsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPREQUESTWITHGREEDYLABELINPATH: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithGreedyLabelInPathInput`](crate::input::HttpRequestWithGreedyLabelInPathInput) using modelled bindings.
     pub struct HttpRequestWithGreedyLabelInPathInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithGreedyLabelInPathInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpRequestWithGreedyLabelInPathInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithGreedyLabelInPathInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithGreedyLabelInPathInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithGreedyLabelInPathInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHGREEDYLABELINPATH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_request_with_greedy_label_in_path::de_http_request_with_greedy_label_in_path_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Tests requests with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_boolean_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Boolean1", "true")
             .header("X-Boolean2", "false")
             .header("X-BooleanList", "true, false, true")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_true_bool: ::std::option::Option::Some(true),
                                 header_false_bool: ::std::option::Option::Some(false),
                                 header_boolean_list: ::std::option::Option::Some(vec![
                                     true, false, true,
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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"
         );
         HttpRequestWithGreedyLabelInPathInputFuture {
             inner: Box::pin(fut),
--
+        }
-40500
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithGreedyLabelInPathOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_greedy_label_in_path::ser_http_request_with_greedy_label_in_path_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
     /// Tests requests with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_timestamp_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header(
                 "X-TimestampList",
                 "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT",
-+
+            )
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_timestamp_list: ::std::option::Option::Some(vec![
                                     ::aws_smithy_types::DateTime::from_fractional_secs(
                                         1576540098, 0_f64,
                                     ),
                                     ::aws_smithy_types::DateTime::from_fractional_secs(
                                         1576540098, 0_f64,
                                     ),
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-40671
+                    }
                 },
-+
+            )
             .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"
         );
-40682
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithGreedyLabelInPathError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_greedy_label_in_path::ser_http_request_with_greedy_label_in_path_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPREQUESTWITHLABELSANDTIMESTAMPFORMAT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithLabelsAndTimestampFormatInput`](crate::input::HttpRequestWithLabelsAndTimestampFormatInput) using modelled bindings.
     pub struct HttpRequestWithLabelsAndTimestampFormatInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsAndTimestampFormatInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpRequestWithLabelsAndTimestampFormatInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithLabelsAndTimestampFormatInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithLabelsAndTimestampFormatInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithLabelsAndTimestampFormatInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHLABELSANDTIMESTAMPFORMAT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::de_http_request_with_labels_and_timestamp_format_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
     /// Tests requests with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_enum_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Enum", "Foo")
             .header("X-EnumList", "Foo, Bar, Baz")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_enum: ::std::option::Option::Some(
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 ),
                                 header_enum_list: ::std::option::Option::Some(vec![
                                     "Foo"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                     "Bar"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                     "Baz"
                                         .parse::<crate::model::FooEnum>()
                                         .expect("static value validated to member"),
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         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"
         );
         HttpRequestWithLabelsAndTimestampFormatInputFuture {
             inner: Box::pin(fut),
--
+        }
-40869
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithLabelsAndTimestampFormatOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::ser_http_request_with_labels_and_timestamp_format_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
     /// Tests requests with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_int_enum_headers_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-IntegerEnum", "1")
             .header("X-IntegerEnumList", "1, 2, 3")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .input_and_output_with_headers(
                 move |input: crate::input::InputAndOutputWithHeadersInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             use ::aws_smithy_protocol_test::FloatEquals;
                             let expected = crate::input::InputAndOutputWithHeadersInput {
                                 header_integer_enum: ::std::option::Option::Some(1),
                                 header_integer_enum_list: ::std::option::Option::Some(vec![
 , 2, 3,
                                 ]),
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                             };
                             ::pretty_assertions::assert_eq!(
                                 input.header_string,
                                 expected.header_string,
                                 "Unexpected value for `header_string`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_byte,
                                 expected.header_byte,
                                 "Unexpected value for `header_byte`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_short,
                                 expected.header_short,
                                 "Unexpected value for `header_short`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer,
                                 expected.header_integer,
                                 "Unexpected value for `header_integer`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_long,
                                 expected.header_long,
                                 "Unexpected value for `header_long`"
                             );
                             assert!(
                                 input.header_float.float_equals(&expected.header_float),
                                 "Unexpected value for `header_float` {:?} vs. {:?}",
                                 expected.header_float,
                                 input.header_float
                             );
                             assert!(
                                 input.header_double.float_equals(&expected.header_double),
                                 "Unexpected value for `header_double` {:?} vs. {:?}",
                                 expected.header_double,
                                 input.header_double
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_true_bool,
                                 expected.header_true_bool,
                                 "Unexpected value for `header_true_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_false_bool,
                                 expected.header_false_bool,
                                 "Unexpected value for `header_false_bool`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_list,
                                 expected.header_string_list,
                                 "Unexpected value for `header_string_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_string_set,
                                 expected.header_string_set,
                                 "Unexpected value for `header_string_set`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_list,
                                 expected.header_integer_list,
                                 "Unexpected value for `header_integer_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_boolean_list,
                                 expected.header_boolean_list,
                                 "Unexpected value for `header_boolean_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_timestamp_list,
                                 expected.header_timestamp_list,
                                 "Unexpected value for `header_timestamp_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum,
                                 expected.header_enum,
                                 "Unexpected value for `header_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_enum_list,
                                 expected.header_enum_list,
                                 "Unexpected value for `header_enum_list`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum,
                                 expected.header_integer_enum,
                                 "Unexpected value for `header_integer_enum`"
                             );
                             ::pretty_assertions::assert_eq!(
                                 input.header_integer_enum_list,
                                 expected.header_integer_enum_list,
                                 "Unexpected value for `header_integer_enum_list`"
                             );
                             let response = crate::output::InputAndOutputWithHeadersOutput {
                                 header_string: ::std::option::Option::None,
                                 header_byte: ::std::option::Option::None,
                                 header_short: ::std::option::Option::None,
                                 header_integer: ::std::option::Option::None,
                                 header_long: ::std::option::Option::None,
                                 header_float: ::std::option::Option::None,
                                 header_double: ::std::option::Option::None,
                                 header_true_bool: ::std::option::Option::None,
                                 header_false_bool: ::std::option::Option::None,
                                 header_string_list: ::std::option::Option::None,
                                 header_string_set: ::std::option::Option::None,
                                 header_integer_list: ::std::option::Option::None,
                                 header_boolean_list: ::std::option::Option::None,
                                 header_timestamp_list: ::std::option::Option::None,
                                 header_enum: ::std::option::Option::None,
                                 header_enum_list: ::std::option::Option::None,
                                 header_integer_enum: ::std::option::Option::None,
                                 header_integer_enum_list: ::std::option::Option::None,
                             };
                             Ok(response)
                         };
                         sender.send(()).await.expect("receiver dropped early");
                         result
-41033
+                    }
                 },
-+
+            )
             .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"
         );
-41044
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithLabelsAndTimestampFormatError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::ser_http_request_with_labels_and_timestamp_format_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_header_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Double", "NaN")
             .header("X-Float", "NaN")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .input_and_output_with_headers(move |input: crate::input::InputAndOutputWithHeadersInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::InputAndOutputWithHeadersInput {
                 header_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 header_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 header_string:
                     ::std::option::Option::None
-+
+                ,
                 header_byte:
                     ::std::option::Option::None
-+
+                ,
                 header_short:
                     ::std::option::Option::None
-+
+                ,
                 header_integer:
                     ::std::option::Option::None
-+
+                ,
                 header_long:
                     ::std::option::Option::None
-+
+                ,
                 header_true_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_false_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_string_list:
                     ::std::option::Option::None
-+
+                ,
                 header_string_set:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 header_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-41128
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_HTTPREQUESTWITHLABELS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`HttpRequestWithLabelsInput`](crate::input::HttpRequestWithLabelsInput) using modelled bindings.
     pub struct HttpRequestWithLabelsInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::HttpRequestWithLabelsInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for HttpRequestWithLabelsInputFuture {
     type Output = Result<
         crate::input::HttpRequestWithLabelsInput,
         ::aws_smithy_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)
-+
+        ;
         ::pretty_assertions::assert_eq!(input.header_string, expected.header_string, "Unexpected value for `header_string`");
         ::pretty_assertions::assert_eq!(input.header_byte, expected.header_byte, "Unexpected value for `header_byte`");
         ::pretty_assertions::assert_eq!(input.header_short, expected.header_short, "Unexpected value for `header_short`");
         ::pretty_assertions::assert_eq!(input.header_integer, expected.header_integer, "Unexpected value for `header_integer`");
         ::pretty_assertions::assert_eq!(input.header_long, expected.header_long, "Unexpected value for `header_long`");
         assert!(input.header_float.float_equals(&expected.header_float),
                                             "Unexpected value for `header_float` {:?} vs. {:?}", expected.header_float, input.header_float);
         assert!(input.header_double.float_equals(&expected.header_double),
                                             "Unexpected value for `header_double` {:?} vs. {:?}", expected.header_double, input.header_double);
         ::pretty_assertions::assert_eq!(input.header_true_bool, expected.header_true_bool, "Unexpected value for `header_true_bool`");
         ::pretty_assertions::assert_eq!(input.header_false_bool, expected.header_false_bool, "Unexpected value for `header_false_bool`");
         ::pretty_assertions::assert_eq!(input.header_string_list, expected.header_string_list, "Unexpected value for `header_string_list`");
         ::pretty_assertions::assert_eq!(input.header_string_set, expected.header_string_set, "Unexpected value for `header_string_set`");
         ::pretty_assertions::assert_eq!(input.header_integer_list, expected.header_integer_list, "Unexpected value for `header_integer_list`");
         ::pretty_assertions::assert_eq!(input.header_boolean_list, expected.header_boolean_list, "Unexpected value for `header_boolean_list`");
         ::pretty_assertions::assert_eq!(input.header_timestamp_list, expected.header_timestamp_list, "Unexpected value for `header_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.header_enum, expected.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(input.header_enum_list, expected.header_enum_list, "Unexpected value for `header_enum_list`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum, expected.header_integer_enum, "Unexpected value for `header_integer_enum`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum_list, expected.header_integer_enum_list, "Unexpected value for `header_integer_enum_list`");
         let response =
             crate::output::InputAndOutputWithHeadersOutput {
                 header_string:
                     ::std::option::Option::None
-+
+                ,
                 header_byte:
                     ::std::option::Option::None
-+
+                ,
                 header_short:
                     ::std::option::Option::None
-+
+                ,
                 header_integer:
                     ::std::option::Option::None
-+
+                ,
                 header_long:
                     ::std::option::Option::None
-+
+                ,
                 header_float:
                     ::std::option::Option::None
-+
+                ,
                 header_double:
                     ::std::option::Option::None
-+
+                ,
                 header_true_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_false_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_string_list:
                     ::std::option::Option::None
-+
+                ,
                 header_string_set:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 header_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-+
+            }
-+
+        ;
         Ok(response) };
                                 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"
         );
-41221
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::HttpRequestWithLabelsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = HttpRequestWithLabelsInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_HTTPREQUESTWITHLABELS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_header_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Double", "Infinity")
             .header("X-Float", "Infinity")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .input_and_output_with_headers(move |input: crate::input::InputAndOutputWithHeadersInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::InputAndOutputWithHeadersInput {
                 header_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 header_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 header_string:
                     ::std::option::Option::None
-+
+                ,
                 header_byte:
                     ::std::option::Option::None
-+
+                ,
                 header_short:
                     ::std::option::Option::None
-+
+                ,
                 header_integer:
                     ::std::option::Option::None
-+
+                ,
                 header_long:
                     ::std::option::Option::None
-+
+                ,
                 header_true_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_false_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_string_list:
                     ::std::option::Option::None
-+
+                ,
                 header_string_set:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 header_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-41305
+            }
             crate::protocol_serde::shape_http_request_with_labels::de_http_request_with_labels_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
-+
+        ;
         ::pretty_assertions::assert_eq!(input.header_string, expected.header_string, "Unexpected value for `header_string`");
         ::pretty_assertions::assert_eq!(input.header_byte, expected.header_byte, "Unexpected value for `header_byte`");
         ::pretty_assertions::assert_eq!(input.header_short, expected.header_short, "Unexpected value for `header_short`");
         ::pretty_assertions::assert_eq!(input.header_integer, expected.header_integer, "Unexpected value for `header_integer`");
         ::pretty_assertions::assert_eq!(input.header_long, expected.header_long, "Unexpected value for `header_long`");
         assert!(input.header_float.float_equals(&expected.header_float),
                                             "Unexpected value for `header_float` {:?} vs. {:?}", expected.header_float, input.header_float);
         assert!(input.header_double.float_equals(&expected.header_double),
                                             "Unexpected value for `header_double` {:?} vs. {:?}", expected.header_double, input.header_double);
         ::pretty_assertions::assert_eq!(input.header_true_bool, expected.header_true_bool, "Unexpected value for `header_true_bool`");
         ::pretty_assertions::assert_eq!(input.header_false_bool, expected.header_false_bool, "Unexpected value for `header_false_bool`");
         ::pretty_assertions::assert_eq!(input.header_string_list, expected.header_string_list, "Unexpected value for `header_string_list`");
         ::pretty_assertions::assert_eq!(input.header_string_set, expected.header_string_set, "Unexpected value for `header_string_set`");
         ::pretty_assertions::assert_eq!(input.header_integer_list, expected.header_integer_list, "Unexpected value for `header_integer_list`");
         ::pretty_assertions::assert_eq!(input.header_boolean_list, expected.header_boolean_list, "Unexpected value for `header_boolean_list`");
         ::pretty_assertions::assert_eq!(input.header_timestamp_list, expected.header_timestamp_list, "Unexpected value for `header_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.header_enum, expected.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(input.header_enum_list, expected.header_enum_list, "Unexpected value for `header_enum_list`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum, expected.header_integer_enum, "Unexpected value for `header_integer_enum`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum_list, expected.header_integer_enum_list, "Unexpected value for `header_integer_enum_list`");
         let response =
             crate::output::InputAndOutputWithHeadersOutput {
                 header_string:
                     ::std::option::Option::None
-+
+                ,
                 header_byte:
                     ::std::option::Option::None
-+
+                ,
                 header_short:
                     ::std::option::Option::None
-+
+                ,
                 header_integer:
                     ::std::option::Option::None
-+
+                ,
                 header_long:
                     ::std::option::Option::None
-+
+                ,
                 header_float:
                     ::std::option::Option::None
-+
+                ,
                 header_double:
                     ::std::option::Option::None
-+
+                ,
                 header_true_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_false_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_string_list:
                     ::std::option::Option::None
-+
+                ,
                 header_string_set:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 header_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-+
+            }
-+
+        ;
         Ok(response) };
                                 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"
         );
         HttpRequestWithLabelsInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::HttpRequestWithLabelsOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
-41398
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::HttpRequestWithLabelsError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderInputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_header_inputs_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/InputAndOutputWithHeaders")
             .method("POST")
             .header("X-Double", "-Infinity")
             .header("X-Float", "-Infinity")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
                         .input_and_output_with_headers(move |input: crate::input::InputAndOutputWithHeadersInput| {
                             let sender = sender.clone();
                             async move {
                                 let result = { use ::aws_smithy_protocol_test::FloatEquals;
         let expected =
             crate::input::InputAndOutputWithHeadersInput {
                 header_float:
                     ::std::option::Option::Some(
                         <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 header_double:
                     ::std::option::Option::Some(
                         <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity").expect("invalid string for number")
-+
+                    )
-+
+                ,
                 header_string:
                     ::std::option::Option::None
-+
+                ,
                 header_byte:
                     ::std::option::Option::None
-+
+                ,
                 header_short:
                     ::std::option::Option::None
-+
+                ,
                 header_integer:
                     ::std::option::Option::None
-+
+                ,
                 header_long:
                     ::std::option::Option::None
-+
+                ,
                 header_true_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_false_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_string_list:
                     ::std::option::Option::None
-+
+                ,
                 header_string_set:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 header_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-41482
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_MEDIATYPEHEADER: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`MediaTypeHeaderInput`](crate::input::MediaTypeHeaderInput) using modelled bindings.
     pub struct MediaTypeHeaderInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::MediaTypeHeaderInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for MediaTypeHeaderInputFuture {
     type Output = Result<
         crate::input::MediaTypeHeaderInput,
         ::aws_smithy_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_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MediaTypeHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MediaTypeHeaderInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MEDIATYPEHEADER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-+
+        ;
         ::pretty_assertions::assert_eq!(input.header_string, expected.header_string, "Unexpected value for `header_string`");
         ::pretty_assertions::assert_eq!(input.header_byte, expected.header_byte, "Unexpected value for `header_byte`");
         ::pretty_assertions::assert_eq!(input.header_short, expected.header_short, "Unexpected value for `header_short`");
         ::pretty_assertions::assert_eq!(input.header_integer, expected.header_integer, "Unexpected value for `header_integer`");
         ::pretty_assertions::assert_eq!(input.header_long, expected.header_long, "Unexpected value for `header_long`");
         assert!(input.header_float.float_equals(&expected.header_float),
                                             "Unexpected value for `header_float` {:?} vs. {:?}", expected.header_float, input.header_float);
         assert!(input.header_double.float_equals(&expected.header_double),
                                             "Unexpected value for `header_double` {:?} vs. {:?}", expected.header_double, input.header_double);
         ::pretty_assertions::assert_eq!(input.header_true_bool, expected.header_true_bool, "Unexpected value for `header_true_bool`");
         ::pretty_assertions::assert_eq!(input.header_false_bool, expected.header_false_bool, "Unexpected value for `header_false_bool`");
         ::pretty_assertions::assert_eq!(input.header_string_list, expected.header_string_list, "Unexpected value for `header_string_list`");
         ::pretty_assertions::assert_eq!(input.header_string_set, expected.header_string_set, "Unexpected value for `header_string_set`");
         ::pretty_assertions::assert_eq!(input.header_integer_list, expected.header_integer_list, "Unexpected value for `header_integer_list`");
         ::pretty_assertions::assert_eq!(input.header_boolean_list, expected.header_boolean_list, "Unexpected value for `header_boolean_list`");
         ::pretty_assertions::assert_eq!(input.header_timestamp_list, expected.header_timestamp_list, "Unexpected value for `header_timestamp_list`");
         ::pretty_assertions::assert_eq!(input.header_enum, expected.header_enum, "Unexpected value for `header_enum`");
         ::pretty_assertions::assert_eq!(input.header_enum_list, expected.header_enum_list, "Unexpected value for `header_enum_list`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum, expected.header_integer_enum, "Unexpected value for `header_integer_enum`");
         ::pretty_assertions::assert_eq!(input.header_integer_enum_list, expected.header_integer_enum_list, "Unexpected value for `header_integer_enum_list`");
         let response =
             crate::output::InputAndOutputWithHeadersOutput {
                 header_string:
                     ::std::option::Option::None
-+
+                ,
                 header_byte:
                     ::std::option::Option::None
-+
+                ,
                 header_short:
                     ::std::option::Option::None
-+
+                ,
                 header_integer:
                     ::std::option::Option::None
-+
+                ,
                 header_long:
                     ::std::option::Option::None
-+
+                ,
                 header_float:
                     ::std::option::Option::None
-+
+                ,
                 header_double:
                     ::std::option::Option::None
-+
+                ,
                 header_true_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_false_bool:
                     ::std::option::Option::None
-+
+                ,
                 header_string_list:
                     ::std::option::Option::None
-+
+                ,
                 header_string_set:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_list:
                     ::std::option::Option::None
-+
+                ,
                 header_boolean_list:
                     ::std::option::Option::None
-+
+                ,
                 header_timestamp_list:
                     ::std::option::Option::None
-+
+                ,
                 header_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_enum_list:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum:
                     ::std::option::Option::None
-+
+                ,
                 header_integer_enum_list:
                     ::std::option::Option::None
-+
+                ,
-41560
+            }
             crate::protocol_serde::shape_media_type_header::de_media_type_header_http_request(
                 request,
--
+            )
-+
+        ;
         Ok(response) };
                                 sender.send(()).await.expect("receiver dropped early");
                                 result
-+
+                            }
                         })
                         .build_unchecked();
         let http_response = ::tower::ServiceExt::oneshot(service, http_request)
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
             .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"
         );
         MediaTypeHeaderInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MediaTypeHeaderOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_media_type_header::ser_media_type_header_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
--
+    }
--
+}
--
 const CONTENT_TYPE_TIMESTAMPFORMATHEADERS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`TimestampFormatHeadersInput`](crate::input::TimestampFormatHeadersInput) using modelled bindings.
     pub struct TimestampFormatHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::TimestampFormatHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-41575
+    }
--
+}
--
 impl std::future::Future for TimestampFormatHeadersInputFuture {
     type Output = Result<
         crate::input::TimestampFormatHeadersInput,
         ::aws_smithy_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)
     /// Tests responses with string header bindings
     /// Test ID: RestJsonInputAndOutputWithStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_string_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_string: ::std::option::Option::Some("Hello".to_owned()),
             header_string_list: ::std::option::Option::Some(vec![
                 "a".to_owned(),
                 "b".to_owned(),
                 "c".to_owned(),
             ]),
             header_string_set: ::std::option::Option::Some(
                 vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]
                     .try_into()
                     .expect("this is only used in tests"),
             ),
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-String", "Hello"),
             ("X-StringList", "a, b, c"),
             ("X-StringSet", "a, b, c"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41624
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::TimestampFormatHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = TimestampFormatHeadersInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_TIMESTAMPFORMATHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Tests responses with string list header bindings that require quoting
     /// Test ID: RestJsonInputAndOutputWithQuotedStringHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_quoted_string_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_string_list: ::std::option::Option::Some(vec![
                 "b,c".to_owned(),
                 "\"def\"".to_owned(),
                 "a".to_owned(),
             ]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         TimestampFormatHeadersInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::TimestampFormatHeadersOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_timestamp_format_headers::ser_timestamp_format_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_NULLANDEMPTYHEADERSSERVER: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullAndEmptyHeadersServerInput`](crate::input::NullAndEmptyHeadersServerInput) using modelled bindings.
     pub struct NullAndEmptyHeadersServerInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersServerInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
--
+    }
--
+}
--
 impl std::future::Future for NullAndEmptyHeadersServerInputFuture {
     type Output = Result<
         crate::input::NullAndEmptyHeadersServerInput,
         ::aws_smithy_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)
         let expected_headers = [("X-StringList", "\"b,c\", \"\\\"def\\\"\", a")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41665
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullAndEmptyHeadersServerInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullAndEmptyHeadersServerInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLANDEMPTYHEADERSSERVER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_null_and_empty_headers_server::de_null_and_empty_headers_server_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Tests responses with numeric header bindings
     /// Test ID: RestJsonInputAndOutputWithNumericHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_numeric_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_byte: ::std::option::Option::Some(1),
             header_short: ::std::option::Option::Some(123),
             header_integer: ::std::option::Option::Some(123),
             header_long: ::std::option::Option::Some(123),
             header_float: ::std::option::Option::Some(1.1_f32),
             header_double: ::std::option::Option::Some(1.1_f64),
             header_integer_list: ::std::option::Option::Some(vec![1, 2, 3]),
             header_string: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         NullAndEmptyHeadersServerInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullAndEmptyHeadersServerOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_and_empty_headers_server::ser_null_and_empty_headers_server_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
--
+    }
--
+}
--
 const CONTENT_TYPE_NULLANDEMPTYHEADERSCLIENT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NullAndEmptyHeadersClientInput`](crate::input::NullAndEmptyHeadersClientInput) using modelled bindings.
     pub struct NullAndEmptyHeadersClientInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NullAndEmptyHeadersClientInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
         let expected_headers = [
             ("X-Byte", "1"),
             ("X-Double", "1.1"),
             ("X-Float", "1.1"),
             ("X-Integer", "123"),
             ("X-IntegerList", "1, 2, 3"),
             ("X-Long", "123"),
             ("X-Short", "123"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41710
+    }
--
+}
--
 impl std::future::Future for NullAndEmptyHeadersClientInputFuture {
     type Output = Result<
         crate::input::NullAndEmptyHeadersClientInput,
         ::aws_smithy_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)
     /// Tests responses with boolean header bindings
     /// Test ID: RestJsonInputAndOutputWithBooleanHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_boolean_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_true_bool: ::std::option::Option::Some(true),
             header_false_bool: ::std::option::Option::Some(false),
             header_boolean_list: ::std::option::Option::Some(vec![true, false, true]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Boolean1", "true"),
             ("X-Boolean2", "false"),
             ("X-BooleanList", "true, false, true"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41751
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullAndEmptyHeadersClientInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullAndEmptyHeadersClientInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLANDEMPTYHEADERSCLIENT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_null_and_empty_headers_client::de_null_and_empty_headers_client_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Tests responses with timestamp header bindings
     /// Test ID: RestJsonInputAndOutputWithTimestampHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_timestamp_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_timestamp_list: ::std::option::Option::Some(vec![
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
                 ::aws_smithy_types::DateTime::from_fractional_secs(1576540098, 0_f64),
             ]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         NullAndEmptyHeadersClientInputFuture {
             inner: Box::pin(fut),
--
+        }
         let expected_headers = [(
             "X-TimestampList",
             "Mon, 16 Dec 2019 23:48:18 GMT, Mon, 16 Dec 2019 23:48:18 GMT",
         )];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41794
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullAndEmptyHeadersClientOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_and_empty_headers_client::ser_null_and_empty_headers_client_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
     /// Tests responses with enum header bindings
     /// Test ID: RestJsonInputAndOutputWithEnumHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_enum_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_enum: ::std::option::Option::Some(
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ),
             header_enum_list: ::std::option::Option::Some(vec![
                 "Foo"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "Bar"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
                 "Baz"
                     .parse::<crate::model::FooEnum>()
                     .expect("static value validated to member"),
             ]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Enum", "Foo"), ("X-EnumList", "Foo, Bar, Baz")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41845
+    }
--
+}
--
 const CONTENT_TYPE_INPUTANDOUTPUTWITHHEADERS: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`InputAndOutputWithHeadersInput`](crate::input::InputAndOutputWithHeadersInput) using modelled bindings.
     pub struct InputAndOutputWithHeadersInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::InputAndOutputWithHeadersInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
     /// Tests responses with intEnum header bindings
     /// Test ID: RestJsonInputAndOutputWithIntEnumHeaders
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_input_and_output_with_int_enum_headers_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_integer_enum: ::std::option::Option::Some(1),
             header_integer_enum_list: ::std::option::Option::Some(vec![1, 2, 3]),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_float: ::std::option::Option::None,
             header_double: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-IntegerEnum", "1"), ("X-IntegerEnumList", "1, 2, 3")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41882
+    }
--
+}
--
 impl std::future::Future for InputAndOutputWithHeadersInputFuture {
     type Output = Result<
         crate::input::InputAndOutputWithHeadersInput,
         ::aws_smithy_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)
     /// Supports handling NaN float header values.
     /// Test ID: RestJsonSupportsNaNFloatHeaderOutputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_na_n_float_header_outputs_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_float: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             header_double: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("NaN")
                     .expect("invalid string for number"),
             ),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Double", "NaN"), ("X-Float", "NaN")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41925
+    }
--
+}
--
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::InputAndOutputWithHeadersInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
--
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
--
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = InputAndOutputWithHeadersInputFuture;
--
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_INPUTANDOUTPUTWITHHEADERS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
--
+            }
             crate::protocol_serde::shape_input_and_output_with_headers::de_input_and_output_with_headers_http_request(request)
                             .await
                             .map_err(Into::into)
     /// Supports handling Infinity float header values.
     /// Test ID: RestJsonSupportsInfinityFloatHeaderOutputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_infinity_float_header_outputs_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_float: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             header_double: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("Infinity")
                     .expect("invalid string for number"),
             ),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
--
+                )
             },
         use ::aws_smithy_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()
         );
         InputAndOutputWithHeadersInputFuture {
             inner: Box::pin(fut),
--
+        }
--
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::InputAndOutputWithHeadersOutput
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+                        }
--
+                    }
         let expected_headers = [("X-Double", "Infinity"), ("X-Float", "Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-41968
+    }
--
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::error::InputAndOutputWithHeadersError
--
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_error(&self) {
             Ok(mut response) => {
                 response.extensions_mut().insert(::aws_smithy_http_server::extension::ModeledErrorExtension::new(self.name()));
                 response
             },
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
--
+            }
--
+        }
     /// Supports handling -Infinity float header values.
     /// Test ID: RestJsonSupportsNegativeInfinityFloatHeaderOutputs
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_supports_negative_infinity_float_header_outputs_response() {
         let output = crate::output::InputAndOutputWithHeadersOutput {
             header_float: ::std::option::Option::Some(
                 <f32 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             header_double: ::std::option::Option::Some(
                 <f64 as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive("-Infinity")
                     .expect("invalid string for number"),
             ),
             header_string: ::std::option::Option::None,
             header_byte: ::std::option::Option::None,
             header_short: ::std::option::Option::None,
             header_integer: ::std::option::Option::None,
             header_long: ::std::option::Option::None,
             header_true_bool: ::std::option::Option::None,
             header_false_bool: ::std::option::Option::None,
             header_string_list: ::std::option::Option::None,
             header_string_set: ::std::option::Option::None,
             header_integer_list: ::std::option::Option::None,
             header_boolean_list: ::std::option::Option::None,
             header_timestamp_list: ::std::option::Option::None,
             header_enum: ::std::option::Option::None,
             header_enum_list: ::std::option::Option::None,
             header_integer_enum: ::std::option::Option::None,
             header_integer_enum_list: ::std::option::Option::None,
         };
         use ::aws_smithy_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-Double", "-Infinity"), ("X-Float", "-Infinity")];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
-42011
+    }
-42012
+}
-42013
 const CONTENT_TYPE_UNITINPUTANDOUTPUT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`UnitInputAndOutputInput`](crate::input::UnitInputAndOutputInput) using modelled bindings.
     pub struct UnitInputAndOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::UnitInputAndOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-42020
+    }

↧ Expand context

-42021
+}
-42022
 impl std::future::Future for UnitInputAndOutputInputFuture {
     type Output = Result<
         crate::input::UnitInputAndOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-42028
     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)
-42035
+    }
-42036
+}
-42037
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,

@@ -41253,42066 +41312,42233 @@

↥ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42072
+                )
             },
         );
         UnitInputAndOutputInputFuture {
             inner: Box::pin(fut),
-42077
+        }
-42078
+    }
-42079
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::UnitInputAndOutputOutput
-42084
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

         match crate::protocol_serde::shape_unit_input_and_output::ser_unit_input_and_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42091
+                        }
-42092
+                    }
-42093
+    }
-42094
+}
-42095
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod unit_input_and_output_test {
-+
     /// A unit type input serializes no payload. When clients do not
     /// need to serialize any data in the payload, they should omit
     /// a payload altogether.
     /// Test ID: RestJsonUnitInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_unit_input_and_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/UnitInputAndOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .unit_input_and_output(move |input: crate::input::UnitInputAndOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::UnitInputAndOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::UnitInputAndOutputOutput {};
                         response
                     };
                     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"
         );
-+
+    }
     /// Servers should allow the accept header to be set to the
     /// default content-type.
     /// Test ID: RestJsonUnitInputAllowsAccept
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_unit_input_allows_accept_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/UnitInputAndOutput")
             .method("POST")
             .header("Accept", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .unit_input_and_output(move |input: crate::input::UnitInputAndOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::UnitInputAndOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::UnitInputAndOutputOutput {};
                         response
                     };
                     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"
         );
-+
+    }
     /// When an operation defines Unit output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonUnitInputAndOutputNoOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_unit_input_and_output_no_output_response() {
         let output = crate::output::UnitInputAndOutputOutput {};
         use ::aws_smithy_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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_EMPTYINPUTANDEMPTYOUTPUT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EmptyInputAndEmptyOutputInput`](crate::input::EmptyInputAndEmptyOutputInput) using modelled bindings.
     pub struct EmptyInputAndEmptyOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyInputAndEmptyOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-42210
+    }
-42211
+}
-42212
 impl std::future::Future for EmptyInputAndEmptyOutputInputFuture {

↧ Expand context

     type Output = Result<
         crate::input::EmptyInputAndEmptyOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-42218
     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)
-42225
+    }
-42226
+}
-42227
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyInputAndEmptyOutputInput
 where

@@ -41335,42256 +41394,42435 @@

↥ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42262
+                )
             },
         );
         EmptyInputAndEmptyOutputInputFuture {
             inner: Box::pin(fut),
-42267
+        }
-42268
+    }
-42269
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyInputAndEmptyOutputOutput
-42274
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

         match crate::protocol_serde::shape_empty_input_and_empty_output::ser_empty_input_and_empty_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42281
+                        }
-42282
+                    }
-42283
+    }
-42284
+}
-42285
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_input_and_empty_output_test {
-+
     /// Clients should not serialize a JSON payload when no parameters
     /// are given that are sent in the body. A service will tolerate
     /// clients that omit a payload or that send a JSON object.
     /// Test ID: RestJsonEmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_empty_input_and_empty_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EmptyInputAndEmptyOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .empty_input_and_empty_output(
                 move |input: crate::input::EmptyInputAndEmptyOutputInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EmptyInputAndEmptyOutputInput {};
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::EmptyInputAndEmptyOutputOutput {};
                             response
                         };
                         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"
         );
-+
+    }
     /// Similar to RestJsonEmptyInputAndEmptyOutput, but ensures that
     /// services gracefully handles receiving a JSON object.
     /// Test ID: RestJsonEmptyInputAndEmptyOutputWithJson
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_empty_input_and_empty_output_with_json_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/EmptyInputAndEmptyOutput")
             .method("POST")
             .header("Content-Type", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .empty_input_and_empty_output(
                 move |input: crate::input::EmptyInputAndEmptyOutputInput| {
                     let sender = sender.clone();
                     async move {
                         let result = {
                             let expected = crate::input::EmptyInputAndEmptyOutputInput {};
                             ::pretty_assertions::assert_eq!(input, expected);
                             let response = crate::output::EmptyInputAndEmptyOutputOutput {};
                             response
                         };
                         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"
         );
-+
+    }
     /// As of January 2021, server implementations are expected to
     /// respond with a JSON object regardless of if the output
     /// parameters are empty.
     /// Test ID: RestJsonEmptyInputAndEmptyOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_empty_input_and_empty_output_response() {
         let output = crate::output::EmptyInputAndEmptyOutputOutput {};
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_NOINPUTANDOUTPUT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NoInputAndOutputInput`](crate::input::NoInputAndOutputInput) using modelled bindings.
     pub struct NoInputAndOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NoInputAndOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-42412
+    }
-42413
+}
-42414
 impl std::future::Future for NoInputAndOutputInputFuture {

↧ Expand context

     type Output = Result<
         crate::input::NoInputAndOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-42420
     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)
-42427
+    }
-42428
+}
-42429
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NoInputAndOutputInput
 where

@@ -41419,42460 +41478,42634 @@

↥ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42466
+                )
             },
         );
         NoInputAndOutputInputFuture {
             inner: Box::pin(fut),
-42471
+        }
-42472
+    }
-42473
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NoInputAndOutputOutput
-42478
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

         match crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42485
+                        }
-42486
+                    }
-42487
+    }
-42488
+}
-42489
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_and_output_test {
-+
     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndOutputOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_output(move |input: crate::input::NoInputAndOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndOutputOutput {};
                         response
                     };
                     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"
         );
-+
+    }
     /// Servers should allow the accept header to be set to the
     /// default content-type.
     /// Test ID: RestJsonNoInputAndOutputAllowsAccept
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_allows_accept_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndOutputOutput")
             .method("POST")
             .header("Accept", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_output(move |input: crate::input::NoInputAndOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndOutputOutput {};
                         response
                     };
                     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"
         );
-+
+    }
     /// Operations that define output and do not bind anything to
     /// the payload return a JSON object in the response.
     /// Test ID: RestJsonNoInputAndOutputWithJson
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_output_with_json_response() {
         let output = crate::output::NoInputAndOutputOutput {};
         use ::aws_smithy_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 = [("Content-Type", "application/json")];
         ::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("application/json"),
         ));
-+
+    }
-+
+}
-+
 const CONTENT_TYPE_NOINPUTANDNOOUTPUT: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`NoInputAndNoOutputInput`](crate::input::NoInputAndNoOutputInput) using modelled bindings.
     pub struct NoInputAndNoOutputInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::NoInputAndNoOutputInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-42611
+    }
-42612
+}
-42613
 impl std::future::Future for NoInputAndNoOutputInputFuture {

↧ Expand context

     type Output = Result<
         crate::input::NoInputAndNoOutputInput,
         ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError,
     >;
-42619
     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)
-42626
+    }
-42627
+}
-42628
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NoInputAndNoOutputInput
 where

@@ -41500,42656 +0,42793 @@

↥ Expand context

         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-42663
+                )
             },
         );
         NoInputAndNoOutputInputFuture {
             inner: Box::pin(fut),
-42668
+        }
-42669
+    }
-42670
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NoInputAndNoOutputOutput
-42675
+{

     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-42682
+                        }
-42683
+                    }
-42684
+    }
-42685
+}
-+
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod no_input_and_no_output_test {
-+
     /// No input serializes no payload. When clients do not need to
     /// serialize any data in the payload, they should omit a payload
     /// altogether.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_no_output_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndNoOutput")
             .method("POST")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_no_output(move |input: crate::input::NoInputAndNoOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndNoOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndNoOutputOutput {};
                         response
                     };
                     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"
         );
-+
+    }
     /// Servers should allow the accept header to be set to the
     /// default content-type.
     /// Test ID: RestJsonNoInputAllowsAccept
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_allows_accept_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/NoInputAndNoOutput")
             .method("POST")
             .header("Accept", "application/json")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::RestJsonConfig::builder().build();
         let service = crate::service::RestJson::builder::<::hyper::body::Body, _, _, _>(config)
             .no_input_and_no_output(move |input: crate::input::NoInputAndNoOutputInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::NoInputAndNoOutputInput {};
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::NoInputAndNoOutputOutput {};
                         response
                     };
                     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"
         );
-+
+    }
     /// When an operation does not define output, the service will respond
     /// with an empty payload, and may optionally include the content-type
     /// header.
     /// Test ID: RestJsonNoInputAndNoOutput
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn rest_json_no_input_and_no_output_response() {
         let output = crate::output::NoInputAndNoOutputOutput {};
         use ::aws_smithy_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");
         // No body.
         ::pretty_assertions::assert_eq!(std::str::from_utf8(&body).unwrap(), "");
-+
+    }
-+
+}

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.mime]
 version = "0.3"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]

 version = "0.1"
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.hyper]
 version = "0.14.12"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
 default = ["aws-lambda", "rt-tokio"]
-51
-52

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "naming_test_ops"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"

 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.mime]
 version = "0.3"
 [dependencies.once_cell]
 version = "1.16"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.bytes]
 version = "1.4.0"
 [dev-dependencies.hyper]
 version = "0.14.12"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 rt-tokio = ["aws-smithy-types/rt-tokio"]
 default = ["aws-lambda", "rt-tokio"]
-53
-54

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_reserved_words_as_members_test {
     /// Test ID: reserved_words
     #[::tokio::test]
     async fn reserved_words_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/")
             .method("POST")
             .header("Content-Type", "application/x-amz-json-1.1")
             .header("X-Amz-Target", "Config.ReservedWordsAsMembers")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\"as\": 5, \"async\": true}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::ConfigConfig::builder().build();
         let service = crate::service::Config::builder::<::hyper::body::Body, _, _, _>(config)
             .reserved_words_as_members(move |input: crate::input::ReservedWordsAsMembersInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::ReservedWordsAsMembersInput {
                             r#as: ::std::option::Option::Some(5),
                             r#async: ::std::option::Option::Some(true),
                             r#enum: ::std::option::Option::None,
                             self_: ::std::option::Option::None,
                             crate_: ::std::option::Option::None,
                             super_: ::std::option::Option::None,
                             build_value: ::std::option::Option::None,
                             default_value: ::std::option::Option::None,
                             send: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::ReservedWordsAsMembersOutput {};
                         Ok(response)
                     };
                     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());
--
+    }
--
+}
 #[cfg(test)]
 #[allow(unreachable_code, unused_variables)]
 mod server_structure_name_punning_test {
     /// Test ID: structure_punning
     #[::tokio::test]
     async fn structure_punning_request() {
         #[allow(unused_mut)]
         let mut http_request = http::Request::builder()
             .uri("/")
             .method("POST")
             .header("Content-Type", "application/x-amz-json-1.1")
             .header("X-Amz-Target", "Config.StructureNamePunning")
             .body(::aws_smithy_http_server::body::Body::from(
                 ::bytes::Bytes::from_static("{\"regular_string\": \"hello!\"}".as_bytes()),
             ))
             .unwrap();
         #[allow(unused_mut)]
         let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
         let config = crate::service::ConfigConfig::builder().build();
         let service = crate::service::Config::builder::<::hyper::body::Body, _, _, _>(config)
             .structure_name_punning(move |input: crate::input::StructureNamePunningInput| {
                 let sender = sender.clone();
                 async move {
                     let result = {
                         let expected = crate::input::StructureNamePunningInput {
                             regular_string: ::std::option::Option::Some("hello!".to_owned()),
                             punned_vec: ::std::option::Option::None,
                         };
                         ::pretty_assertions::assert_eq!(input, expected);
                         let response = crate::output::StructureNamePunningOutput {};
                         response
                     };
                     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());
--
+    }
--
+}
--
 static CONTENT_TYPE_RPCECHO: ::once_cell::sync::Lazy<::mime::Mime> =
     ::once_cell::sync::Lazy::new(|| {
         "application/x-amz-json-1.1"
             .parse::<::mime::Mime>()
             .expect("BUG: MIME parsing failed, content_type is not valid")
     });
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`RpcEchoInput`](crate::input::RpcEchoInput) using modelled bindings.
     pub struct RpcEchoInputFuture {

Server Test

Files changed:

tmp-codegen-diff/codegen-server-test/misc/rust-server-codegen/Cargo.toml

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

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

tmp-codegen-diff/codegen-server-test/naming_test_ops/rust-server-codegen/Cargo.toml

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

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

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

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

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 const CONTENT_TYPE_GETSTORAGE: ::mime::Mime = ::mime::APPLICATION_JSON;
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`GetStorageInput`](crate::input::GetStorageInput) using modelled bindings.
     pub struct GetStorageInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::GetStorageInput, ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError>> + Send>>
-8
+    }
-9
+}
-10
 impl std::future::Future for GetStorageInputFuture {